diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 72d3e7459f7b8447acab31bd26cf831641bdded7..1ba566feb505dc0786454b930914e13a237c4903 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -434,7 +434,7 @@ int com_global_db(int a_argc, char ** a_argv, void **a_str_reply)
         dap_chain_t * l_chain = NULL;
         dap_chain_net_t * l_net = NULL;
 
-        if (dap_chain_node_cli_cmd_values_parse_net_chain_for_json(a_json_arr_reply, &arg_index, a_argc, a_argv, &l_chain, &l_net, CHAIN_TYPE_INVALID) < 0)
+        if (dap_chain_node_cli_cmd_values_parse_net_chain_for_json(*a_json_arr_reply, &arg_index, a_argc, a_argv, &l_chain, &l_net, CHAIN_TYPE_INVALID) < 0)
             return -DAP_CHAIN_NODE_CLI_COM_GLOBAL_DB_PARAM_ERR;
 
         const char *l_cell_str = NULL, *l_chain_str = NULL;
@@ -6910,7 +6910,7 @@ int com_tx_create(int a_argc, char **a_argv, void **a_json_arr_reply)
     // Validator's fee
     if (dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-fee", &str_tmp)) {
         if (!str_tmp) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_TX_CREATE_REQUIRE_FEE, "tx_create requires parameter '-fee'");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_TX_CREATE_REQUIRE_FEE, "tx_create requires parameter '-fee'");
             return DAP_CHAIN_NODE_CLI_COM_TX_CREATE_REQUIRE_FEE;
         }
         l_value_fee = dap_chain_balance_scan(str_tmp);
@@ -7160,7 +7160,7 @@ int com_tx_verify(int a_argc, char **a_argv, void **a_str_reply)
         dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_COM_TX_VERIFY_REQUIRE_PARAMETER_TX, "tx_verify requires parameter '-tx'");
         return DAP_CHAIN_NODE_CLI_COM_TX_VERIFY_REQUIRE_PARAMETER_TX;
     }
-    dap_chain_node_cli_cmd_values_parse_net_chain_for_json(a_json_arr_reply, &l_arg_index, a_argc, a_argv, &l_chain, &l_net,
+    dap_chain_node_cli_cmd_values_parse_net_chain_for_json(*a_json_arr_reply, &l_arg_index, a_argc, a_argv, &l_chain, &l_net,
                                                            CHAIN_TYPE_TX);
     if (!l_net || !l_chain) {
         return DAP_CHAIN_NODE_CLI_COM_TX_VERIFY_NET_CHAIN_UNDEFINED;
diff --git a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
index 2896dcd577b19b84e03839d14206333e42fdc335..6b1c08f6d9078a36286110738aed9efd0c92de13 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_pos_delegate.c
@@ -1527,7 +1527,7 @@ typedef enum s_cli_srv_stake_order_err{
 } s_cli_srv_stake_order_err_t;
 static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, void **a_str_reply, const char *a_hash_out_type)
 {
-    json_object **json_arr_reply = (json_object **)a_str_reply;
+    json_object **a_json_arr_reply = (json_object **)a_str_reply;
     enum {
         CMD_NONE, CMD_CREATE_FEE, CMD_CREATE_VALIDATOR, CMD_CREATE_STAKER, CMD_UPDATE, CMD_LIST,
         CMD_LIST_STAKER, CMD_LIST_VALIDATOR, CMD_LIST_FEE, CMD_REMOVE
@@ -1553,12 +1553,12 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
     const char *l_net_str = NULL;
     dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
     if (!l_net_str) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Command 'order' requires parameter -net");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Command 'order' requires parameter -net");
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
     }
     dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
     if (!l_net) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NET_ERR, "Network %s not found", l_net_str);
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NET_ERR, "Network %s not found", l_net_str);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NET_ERR;
     }
 
@@ -1568,26 +1568,26 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
                    *l_cert_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-value", &l_value_str);
         if (!l_value_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Fee order creation requires parameter -value");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Fee order creation requires parameter -value");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_value = dap_chain_balance_scan(l_value_str);
         if (IS_ZERO_256(l_value)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -value <256 bit integer>");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -value <256 bit integer>");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR;
         }
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
         if (!l_cert_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Fee order creation requires parameter -cert");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Fee order creation requires parameter -cert");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
         if (!l_cert) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR, "Can't load cert %s", l_cert_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR, "Can't load cert %s", l_cert_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR;
         }
         if (!l_cert->enc_key || !l_cert->enc_key->priv_key_data || !l_cert->enc_key->priv_key_data_size) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR, "Certificate \"%s\" has no private key", l_cert_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR, "Certificate \"%s\" has no private key", l_cert_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR;
         }
         // Create the order & put it in GDB
@@ -1596,10 +1596,10 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
             json_object * l_json_obj_create = json_object_new_object();
             json_object_object_add(l_json_obj_create, "status", json_object_new_string("success"));
             json_object_object_add(l_json_obj_create, "order_hash", json_object_new_string(l_order_hash_str));
-            json_object_array_add(*json_arr_reply, l_json_obj_create);
+            json_object_array_add(*a_json_arr_reply, l_json_obj_create);
             DAP_DELETE(l_order_hash_str);
         } else {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_ERR, "Can't compose the order");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_ERR, "Can't compose the order");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_ERR;
         }
     } break;
@@ -1610,48 +1610,48 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
                    *l_tax_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-value_min", &l_value_min_str);
         if (!l_value_min_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -value_min");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -value_min");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_value_min = dap_chain_balance_scan(l_value_min_str);
         if (IS_ZERO_256(l_value_min)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -value_min <256 bit integer>");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -value_min <256 bit integer>");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR;
         }
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-value_max", &l_value_max_str);
         if (!l_value_max_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -value_max");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -value_max");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_value_max = dap_chain_balance_scan(l_value_max_str);
         if (IS_ZERO_256(l_value_max)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -value_max <256 bit integer>");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -value_max <256 bit integer>");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR;
         }
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tax", &l_tax_str);
         if (!l_tax_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -tax");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -tax");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_tax = dap_chain_coins_to_balance(l_tax_str);
         if (compare256(l_tax, dap_chain_coins_to_balance("100.0")) == 1 ||
                 compare256(l_tax, GET_256_FROM_64(100)) == -1) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_TAX_ERR, "Tax must be lower or equal than 100%% and higher or equal than 1.0e-16%%");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_TAX_ERR, "Tax must be lower or equal than 100%% and higher or equal than 1.0e-16%%");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_TAX_ERR;
         }
         const char *l_cert_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
         if (!l_cert_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -cert");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Validator order creation requires parameter -cert");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
         if (!l_cert) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR, "Can't load cert %s", l_cert_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR, "Can't load cert %s", l_cert_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR;
         }
         if (!l_cert->enc_key || !l_cert->enc_key->priv_key_data || !l_cert->enc_key->priv_key_data_size) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR, "Certificate \"%s\" has no private key", l_cert_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR, "Certificate \"%s\" has no private key", l_cert_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR;
         }
         dap_chain_addr_t l_signing_addr;
@@ -1661,13 +1661,13 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
         dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-node_addr", &l_node_addr_str);
         if (l_node_addr_str) {
             if (dap_chain_node_addr_from_str(&l_node_addr, l_node_addr_str)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_UNRECOGNIZED_ADDR_ERR, "Unrecognized node addr %s", l_node_addr_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_UNRECOGNIZED_ADDR_ERR, "Unrecognized node addr %s", l_node_addr_str);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_UNRECOGNIZED_ADDR_ERR;
             }
         }
         int l_result = dap_chain_net_srv_stake_verify_key_and_node(&l_signing_addr, &l_node_addr);
         if (l_result) {
-            dap_json_rpc_error_add(l_result, "Key and node verification error");
+            dap_json_rpc_error_add(*a_json_arr_reply, l_result, "Key and node verification error");
             return l_result;
         }
         // Create the order & put it in GDB
@@ -1676,10 +1676,10 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
             json_object * l_json_obj_create_val = json_object_new_object();
             json_object_object_add(l_json_obj_create_val, "status", json_object_new_string("success"));
             json_object_object_add(l_json_obj_create_val, "order_hash", json_object_new_string(l_order_hash_str));
-            json_object_array_add(*json_arr_reply, l_json_obj_create_val);
+            json_object_array_add(*a_json_arr_reply, l_json_obj_create_val);
             DAP_DELETE(l_order_hash_str);
         } else {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_VAL_ERR, "Can't compose the order");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_VAL_ERR, "Can't compose the order");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_VAL_ERR;
         }
     } break;
@@ -1692,43 +1692,43 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
                    *l_fee_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-value", &l_value_str);
         if (!l_value_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -value");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -value");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_value = dap_chain_balance_scan(l_value_str);
         if (IS_ZERO_256(l_value)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Format -value <256 bit integer>");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Format -value <256 bit integer>");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-fee", &l_fee_str);
         if (!l_fee_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -fee");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -fee");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_fee = dap_chain_balance_scan(l_fee_str);
         if (IS_ZERO_256(l_fee)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -fee <256 bit integer>");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR, "Format -fee <256 bit integer>");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_FORMAT_ERR;
         }
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tax", &l_tax_str);
         if (!l_tax_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -tax");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -tax");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         uint256_t l_tax = dap_chain_coins_to_balance(l_tax_str);
         if (compare256(l_tax, dap_chain_coins_to_balance("100.0")) == 1 ||
                 compare256(l_tax, GET_256_FROM_64(100)) == -1) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_TAX_ERR, "Tax must be lower or equal than 100%% and higher or equal than 1.0e-16%%");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_TAX_ERR, "Tax must be lower or equal than 100%% and higher or equal than 1.0e-16%%");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_TAX_ERR;
         }
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-w", &l_wallet_str);
         if (!l_wallet_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -w");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Staker order creation requires parameter -w");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config),NULL);
         if (!l_wallet) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_WALLET_ERR, "Specified wallet not found");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_WALLET_ERR, "Specified wallet not found");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_WALLET_ERR;
         }
         // Create conditional transaction for order
@@ -1740,7 +1740,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
         if (l_addr_str) {
             dap_chain_addr_t *l_spec_addr = dap_chain_addr_from_str(l_addr_str);
             if (!l_spec_addr) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_ADDR_ERR, "Specified address is ivalid");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_ADDR_ERR, "Specified address is ivalid");
                 DAP_DELETE(l_enc_key);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_ADDR_ERR;
             }
@@ -1753,7 +1753,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
         DAP_DEL_Z(l_enc_key);
         char *l_tx_hash_str = NULL;
         if (!l_tx || !(l_tx_hash_str = s_stake_tx_put(l_tx, l_net, a_hash_out_type))) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_STAKER_ERR, "Can't compose transaction for order, examine log files for details");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_STAKER_ERR, "Can't compose transaction for order, examine log files for details");
             DAP_DEL_Z(l_tx);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_STAKER_ERR;
         }
@@ -1767,17 +1767,17 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
             l_cert_str = "node-addr";
         dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
         if (!l_cert) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR, "Can't load cert %s", l_cert_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR, "Can't load cert %s", l_cert_str);
             DAP_DELETE(l_tx_hash_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_CERT_ERR;
         }
         if (!l_cert->enc_key || !l_cert->enc_key->priv_key_data || !l_cert->enc_key->priv_key_data_size) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR, "Certificate \"%s\" has no private key", l_cert_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR, "Certificate \"%s\" has no private key", l_cert_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_PKEY_IN_CERT_ERR;
         }
         char *l_order_hash_str = s_staker_order_create(l_net, l_value, &l_tx_hash, l_cert->enc_key, a_hash_out_type);
         if (!l_order_hash_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_STAKER_ERR, "Can't compose the order");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_STAKER_ERR, "Can't compose the order");
             DAP_DELETE(l_tx_hash_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_CREATE_STAKER_ERR;
         }
@@ -1787,7 +1787,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
             json_object_object_add(l_json_obj_create_val, "sign", json_object_new_string(l_sign_str));
         json_object_object_add(l_json_obj_create_val, "order_hash", json_object_new_string(l_order_hash_str));
         json_object_object_add(l_json_obj_create_val, "tx_hash", json_object_new_string(l_tx_hash_str));
-        json_object_array_add(*json_arr_reply, l_json_obj_create_val);
+        json_object_array_add(*a_json_arr_reply, l_json_obj_create_val);
         DAP_DELETE(l_order_hash_str);
         DAP_DELETE(l_tx_hash_str);
     } break;
@@ -1797,7 +1797,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
         const char *l_order_hash_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
         if (!l_order_hash_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Command 'srv_stake order %s' requires prameter -order\n",
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Command 'srv_stake order %s' requires prameter -order\n",
                                                 l_cmd_num  == CMD_REMOVE ? "remove" : "update");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
@@ -1809,24 +1809,24 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
             l_order_hash_hex_str = dap_enc_base58_to_hex_str_from_str(l_order_hash_str);
         dap_chain_net_srv_order_t *l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_hex_str);
         if (!l_order) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_ORDER_ERR, "Can't find order %s\n", l_order_hash_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_ORDER_ERR, "Can't find order %s\n", l_order_hash_str);
             DAP_DELETE(l_order_hash_hex_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_ORDER_ERR;
         }
         if (l_order->srv_uid.uint64 != DAP_CHAIN_NET_SRV_STAKE_POS_DELEGATE_ID &&
                 l_order->srv_uid.uint64 != DAP_CHAIN_NET_SRV_STAKE_POS_DELEGATE_ORDERS) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_ORDER_ERR, "Order %s is not a delegated stake order\n", l_order_hash_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_ORDER_ERR, "Order %s is not a delegated stake order\n", l_order_hash_str);
             DAP_DELETE(l_order_hash_hex_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_ORDER_ERR;
         }
         if (l_cmd_num == CMD_REMOVE) {
             if (dap_chain_net_srv_order_delete_by_hash_str_sync(l_net, l_order_hash_hex_str)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_REMOVE_ERR, "Can't remove order %s\n", l_order_hash_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_REMOVE_ERR, "Can't remove order %s\n", l_order_hash_str);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_REMOVE_ERR;
             }
             json_object * l_json_obj_create_val = json_object_new_object();
             json_object_object_add(l_json_obj_create_val, "status", json_object_new_string("success"));
-            json_object_array_add(*json_arr_reply, l_json_obj_create_val);
+            json_object_array_add(*a_json_arr_reply, l_json_obj_create_val);
             DAP_DELETE(l_order_hash_hex_str);
         } else { // l_cmd_num == CMD_UPDATE
             const char *l_cert_str = NULL, *l_value_str = NULL;
@@ -1866,7 +1866,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
         const char *l_net_str = NULL;
         dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
         if (!l_net_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Command 'order list' requires parameter -net");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR, "Command 'order list' requires parameter -net");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_PARAM_ERR;
         }
         const char * l_list_type = NULL;
@@ -1880,7 +1880,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
 
         dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
         if (!l_net) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NET_ERR, "Network %s not found", l_net_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NET_ERR, "Network %s not found", l_net_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NET_ERR;
         }
         json_object* l_json_arr_reply = json_object_new_array();
@@ -1978,11 +1978,11 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, voi
                 json_object_object_del(obj, "timestamp");
             }
         }
-        json_object_array_add(*json_arr_reply, l_json_arr_reply);
+        json_object_array_add(*a_json_arr_reply, l_json_arr_reply);
     } break;
 
     default:
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_SUB_COM_ERR, "Subcommand %s not recognized", a_argv[a_arg_index]);
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_SUB_COM_ERR, "Subcommand %s not recognized", a_argv[a_arg_index]);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_ORDER_NO_SUB_COM_ERR;
     }
     return 0;
@@ -2022,7 +2022,7 @@ typedef enum s_cli_srv_stake_delegate_err{
 } s_cli_srv_stake_delegate_err_t;
 static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index, void **a_str_reply, const char *a_hash_out_type)
 {
-    json_object **json_arr_reply = (json_object **)a_str_reply;
+    json_object **a_json_arr_reply = (json_object **)a_str_reply;
     const char *l_net_str = NULL,
                *l_wallet_str = NULL,
                *l_cert_str = NULL,
@@ -2032,23 +2032,23 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
                *l_order_hash_str = NULL;
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str);
     if (!l_net_str) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -net");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -net");
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
     }
     dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
     if (!l_net) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NET_ERR, "Network %s not found", l_net_str);
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NET_ERR, "Network %s not found", l_net_str);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NET_ERR;
     }
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-w", &l_wallet_str);
     if (!l_wallet_str) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -w");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -w");
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
     }
     const char* l_sign_str = "";
     dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config), NULL);
     if (!l_wallet) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_WALLET_ERR, "Specified wallet not found");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_WALLET_ERR, "Specified wallet not found");
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_WALLET_ERR;
     } else
         l_sign_str = dap_chain_wallet_check_sign(l_wallet);
@@ -2059,7 +2059,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str);
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-order", &l_order_hash_str);
     if (!l_cert_str && !l_order_hash_str) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -cert and/or -order");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -cert and/or -order");
         dap_enc_key_delete(l_enc_key);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
     }
@@ -2067,14 +2067,14 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-value", &l_value_str);
     if (!l_value_str) {
         if (!l_order_hash_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -value");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -value");
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
         }
     } else {
         l_value = dap_chain_balance_scan(l_value_str);
         if (IS_ZERO_256(l_value)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Unrecognized number in '-value' param");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Unrecognized number in '-value' param");
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
         }
@@ -2083,12 +2083,12 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     if (l_cert_str) {
         dap_cert_t *l_signing_cert = dap_cert_find_by_name(l_cert_str);
         if (!l_signing_cert) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_CERT_ERR, "Specified certificate not found");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_CERT_ERR, "Specified certificate not found");
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_CERT_ERR;
         }
         if (dap_chain_addr_fill_from_key(&l_signing_addr, l_signing_cert->enc_key, l_net->pub.id)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_WRONG_CERT_ERR, "Specified certificate is wrong");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_WRONG_CERT_ERR, "Specified certificate is wrong");
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_WRONG_CERT_ERR;
         }
@@ -2097,7 +2097,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     dap_chain_node_addr_t l_node_addr = g_node_addr;
     if (l_node_addr_str) {
         if (dap_chain_node_addr_from_str(&l_node_addr, l_node_addr_str)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_UNRECOGNIZED_ADDR_ERR, "Unrecognized node addr %s", l_node_addr_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_UNRECOGNIZED_ADDR_ERR, "Unrecognized node addr %s", l_node_addr_str);
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_UNRECOGNIZED_ADDR_ERR;
         }
@@ -2105,25 +2105,25 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     if (l_order_hash_str) {
         dap_chain_net_srv_order_t *l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_str);
         if (!l_order) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_ORDER_ERR, "Specified order not found");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_ORDER_ERR, "Specified order not found");
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_ORDER_ERR;
         }
         if (l_order->direction == SERV_DIR_BUY) { // Staker order
             if (!l_cert_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -cert with this order type");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -cert with this order type");
                 dap_enc_key_delete(l_enc_key);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
             }
             if (l_order->ext_size != 0) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ORDER_SIZE_ERR, "Specified order has invalid size");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ORDER_SIZE_ERR, "Specified order has invalid size");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ORDER_SIZE_ERR;
             }
             l_prev_tx = dap_ledger_tx_find_by_hash(l_net->pub.ledger, &l_order->tx_cond_hash);
             if (!l_prev_tx) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_TX_IN_LEDGER_ERR, "The order's conditional transaction not found in ledger");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_TX_IN_LEDGER_ERR, "The order's conditional transaction not found in ledger");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_NO_TX_IN_LEDGER_ERR;
@@ -2131,13 +2131,13 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
             int l_out_num = 0;
             dap_chain_tx_out_cond_t *l_cond = dap_chain_datum_tx_out_cond_get(l_prev_tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, &l_out_num);
             if (!l_cond) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_COND_TX_TYPE_ERR, "The order's conditional transaction has invalid type");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_COND_TX_TYPE_ERR, "The order's conditional transaction has invalid type");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_COND_TX_TYPE_ERR;
             }
             if (dap_ledger_tx_hash_is_used_out_item(l_net->pub.ledger, &l_order->tx_cond_hash, l_out_num, NULL)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_TX_ALREADY_SENT_ERR, "The order's conditional transaction is already spent");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_TX_ALREADY_SENT_ERR, "The order's conditional transaction is already spent");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_TX_ALREADY_SENT_ERR;
@@ -2150,20 +2150,20 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ANOTHER_TICKER_ERR;
             }
             if (l_cond->tsd_size != dap_chain_datum_tx_item_out_cond_create_srv_stake_get_tsd_size()) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_COND_TX_FORMAT_ERR, "The order's conditional transaction has invalid format");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_COND_TX_FORMAT_ERR, "The order's conditional transaction has invalid format");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_COND_TX_FORMAT_ERR;
             }
             if (compare256(l_cond->header.value, l_order->price)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_COND_TX_DIF_VALUE_ERR, "The order's conditional transaction has different value");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_COND_TX_DIF_VALUE_ERR, "The order's conditional transaction has different value");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_COND_TX_DIF_VALUE_ERR;
             }
             if (!dap_chain_addr_is_blank(&l_cond->subtype.srv_stake_pos_delegate.signing_addr) ||
                     l_cond->subtype.srv_stake_pos_delegate.signer_node_addr.uint64) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_COND_TX_NO_ADDR_OR_KEY_ERR, "The order's conditional transaction gas not blank address or key");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_COND_TX_NO_ADDR_OR_KEY_ERR, "The order's conditional transaction gas not blank address or key");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_COND_TX_NO_ADDR_OR_KEY_ERR;
@@ -2185,7 +2185,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
 #endif
         } else {
             if (!l_value_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -value with this order type");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -value with this order type");
                 dap_enc_key_delete(l_enc_key);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
             }
@@ -2194,7 +2194,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
             if (l_sovereign_addr_str) {
                 dap_chain_addr_t *l_spec_addr = dap_chain_addr_from_str(l_sovereign_addr_str);
                 if (!l_spec_addr) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ADDR_ERR, "Specified address is ivalid");
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ADDR_ERR, "Specified address is ivalid");
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ADDR_ERR;
                 }
                 l_sovereign_addr = *l_spec_addr;
@@ -2203,7 +2203,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
                 dap_chain_addr_fill_from_key(&l_sovereign_addr, l_enc_key, l_net->pub.id);
 
             if (l_order->ext_size != sizeof(struct validator_odrer_ext)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ORDER_SIZE_ERR, "Specified order has invalid size");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ORDER_SIZE_ERR, "Specified order has invalid size");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_ORDER_SIZE_ERR;
@@ -2213,7 +2213,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
             if (l_order_hash_str && compare256(l_value, l_order->price) == -1) {
                 const char *l_coin_min_str, *l_value_min_str =
                     dap_uint256_to_char(l_order->price, &l_coin_min_str);
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_LOW_VALUE_ERR, "Number in '-value' param %s is lower than order minimum allowed value %s(%s)",
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_LOW_VALUE_ERR, "Number in '-value' param %s is lower than order minimum allowed value %s(%s)",
                                                   l_value_str, l_coin_min_str, l_value_min_str);
                 dap_enc_key_delete(l_enc_key);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_LOW_VALUE_ERR;
@@ -2221,14 +2221,14 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
             if (l_order_hash_str && compare256(l_value, l_ext->value_max) == 1) {
                 const char *l_coin_max_str, *l_value_max_str =
                     dap_uint256_to_char(l_ext->value_max, &l_coin_max_str);
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_HIGH_VALUE_ERR, "Number in '-value' param %s is higher than order minimum allowed value %s(%s)",
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_HIGH_VALUE_ERR, "Number in '-value' param %s is higher than order minimum allowed value %s(%s)",
                                                   l_value_str, l_coin_max_str, l_value_max_str);
                 dap_enc_key_delete(l_enc_key);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_HIGH_VALUE_ERR;
             }
             dap_sign_t *l_sign = (dap_sign_t *)(l_order->ext_n_sign + l_order->ext_size);
             if (l_sign->header.type.type == SIG_TYPE_NULL) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_UNSIGNED_ORDER_ERR, "Specified order is unsigned");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_UNSIGNED_ORDER_ERR, "Specified order is unsigned");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_UNSIGNED_ORDER_ERR;
@@ -2237,7 +2237,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
             char l_delegated_ticker_str[DAP_CHAIN_TICKER_SIZE_MAX];
             dap_chain_datum_token_get_delegated_ticker(l_delegated_ticker_str, l_net->pub.native_ticker);
             if (dap_strcmp(l_order->price_ticker, l_delegated_ticker_str)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_ORDER_ERR, "Specified order is invalid");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_ORDER_ERR, "Specified order is invalid");
                 dap_enc_key_delete(l_enc_key);
                 DAP_DELETE(l_order);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_INVALID_ORDER_ERR;
@@ -2247,7 +2247,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
         DAP_DELETE(l_order);
         if (compare256(l_sovereign_tax, dap_chain_coins_to_balance("100.0")) == 1 ||
                 compare256(l_sovereign_tax, GET_256_FROM_64(100)) == -1) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_TAX_ERR, "Tax must be lower or equal than 100%% and higher or equal than 1.0e-16%%");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_TAX_ERR, "Tax must be lower or equal than 100%% and higher or equal than 1.0e-16%%");
             dap_enc_key_delete(l_enc_key);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_TAX_ERR;
         }
@@ -2256,27 +2256,27 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
 
     int l_check_result = dap_chain_net_srv_stake_verify_key_and_node(&l_signing_addr, &l_node_addr);
     if (l_check_result) {
-        dap_json_rpc_error_add(l_check_result, "Key and node verification error");
+        dap_json_rpc_error_add(*a_json_arr_reply, l_check_result, "Key and node verification error");
         dap_enc_key_delete(l_enc_key);
         return l_check_result;
     }
     uint256_t l_allowed_min = dap_chain_net_srv_stake_get_allowed_min_value(l_net->pub.id);
     if (compare256(l_value, l_allowed_min) == -1) {
         const char *l_coin_min_str, *l_value_min_str = dap_uint256_to_char(l_allowed_min, &l_coin_min_str);
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_LOW_VALUE_ERR, "Number in '-value' param %s is lower than minimum allowed value %s(%s)",
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_LOW_VALUE_ERR, "Number in '-value' param %s is lower than minimum allowed value %s(%s)",
                                           l_value_str, l_coin_min_str, l_value_min_str);
         dap_enc_key_delete(l_enc_key);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_LOW_VALUE_ERR;
     }
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-fee", &l_fee_str);
     if (!l_fee_str) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -fee");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Command 'delegate' requires parameter -fee");
         dap_enc_key_delete(l_enc_key);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
     }
     uint256_t l_fee = dap_chain_balance_scan(l_fee_str);
     if (IS_ZERO_256(l_fee)) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Unrecognized number in '-fee' param");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR, "Unrecognized number in '-fee' param");
         dap_enc_key_delete(l_enc_key);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_PARAM_ERR;
     }
@@ -2287,7 +2287,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     dap_enc_key_delete(l_enc_key);
     char *l_tx_hash_str;
     if (!l_tx || !(l_tx_hash_str = s_stake_tx_put(l_tx, l_net, a_hash_out_type))) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_STAKE_ERR, "Stake transaction error");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_STAKE_ERR, "Stake transaction error");
         DAP_DEL_Z(l_tx);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_DELEGATE_STAKE_ERR;
     }
@@ -2296,7 +2296,7 @@ static int s_cli_srv_stake_delegate(int a_argc, char **a_argv, int a_arg_index,
     json_object_object_add(l_json_obj_deligate, "status", json_object_new_string("success"));
     json_object_object_add(l_json_obj_deligate, "sign", json_object_new_string(l_sign_str));
     json_object_object_add(l_json_obj_deligate, "tx_hash", json_object_new_string(l_tx_hash_str));
-    json_object_array_add(*json_arr_reply, l_json_obj_deligate);
+    json_object_array_add(*a_json_arr_reply, l_json_obj_deligate);
     DAP_DELETE(l_tx_hash_str);
     return 0;
 }
@@ -2463,9 +2463,10 @@ typedef enum s_cli_srv_stake_invalidate_err{
 } s_cli_srv_stake_invalidate_err_t;
 static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index, void **a_str_reply, const char *a_hash_out_type)
 {
-    json_object **json_arr_reply = (json_object **)a_str_reply;
+    json_object **a_json_arr_reply = (json_object **)a_str_reply;
     const char *l_net_str = NULL,
                *l_wallet_str = NULL,
+               *l_cert_str = NULL,
                *l_fee_str = NULL,
                *l_tx_hash_str = NULL,
                *l_poa_cert_str = NULL,
@@ -2473,12 +2474,12 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
                *l_signing_pkey_type_str = NULL;
     dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str);
     if (!l_net_str) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -net");
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -net");
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR;
     }
     dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
     if (!l_net) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_ERR, "Network %s not found", l_net_str);
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_ERR, "Network %s not found", l_net_str);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_ERR;
     }
     uint256_t l_fee = {};
@@ -2486,18 +2487,18 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
     if (!l_wallet_str) {
         dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-poa_cert", &l_poa_cert_str);
         if (!l_poa_cert_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -w or -poa_cert");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -w or -poa_cert");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR;
         }
     } else {
         dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-fee", &l_fee_str);
         if (!l_fee_str) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'delegate' requires parameter -fee");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'delegate' requires parameter -fee");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR;
         }
         l_fee = dap_chain_balance_scan(l_fee_str);
         if (IS_ZERO_256(l_fee)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Unrecognized number in '-fee' param");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Unrecognized number in '-fee' param");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR;
         }
     }
@@ -2507,16 +2508,16 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
         if (!l_cert_str) {
             dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-signing_pkey_hash", &l_signing_pkey_hash_str);
             if (!l_signing_pkey_hash_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -tx or -cert or -signing_pkey_hash");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -tx or -cert or -signing_pkey_hash");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR;
             }
             dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-signing_pkey_type", &l_signing_pkey_type_str);
             if (!l_signing_pkey_type_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -signing_pkey_type");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR, "Command 'invalidate' requires parameter -signing_pkey_type");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PARAM_ERR;
             }
             if (dap_sign_type_from_str(l_signing_pkey_type_str).type == SIG_TYPE_NULL) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_PKEY_TYPE_ERR, "Invalid signing_pkey_type %s", l_signing_pkey_type_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_PKEY_TYPE_ERR, "Invalid signing_pkey_type %s", l_signing_pkey_type_str);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_PKEY_TYPE_ERR;
             }
         }
@@ -2530,34 +2531,34 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
         if (l_cert_str) {
             dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
             if (!l_cert) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_CERT_ERR, "Specified certificate not found");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_CERT_ERR, "Specified certificate not found");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_CERT_ERR;
             }
             if (!l_cert->enc_key->priv_key_data || l_cert->enc_key->priv_key_data_size == 0) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PKEY_ERR, "It is not possible to invalidate a stake using a public key.");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PKEY_ERR, "It is not possible to invalidate a stake using a public key.");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_PKEY_ERR;
             }
             if (dap_chain_addr_fill_from_key(&l_signing_addr, l_cert->enc_key, l_net->pub.id)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_WRONG_CERT_ERR, "Specified certificate is wrong");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_WRONG_CERT_ERR, "Specified certificate is wrong");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_WRONG_CERT_ERR;
             }
         } else {
             dap_hash_fast_t l_pkey_hash = {};
             if (dap_chain_hash_fast_from_str(l_signing_pkey_hash_str, &l_pkey_hash)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_PKEY_ERR, "Invalid pkey hash format");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_PKEY_ERR, "Invalid pkey hash format");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_PKEY_ERR;
             }
             dap_chain_addr_fill(&l_signing_addr, dap_sign_type_from_str(l_signing_pkey_type_str), &l_pkey_hash, l_net->pub.id);
         }
         dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(l_net->pub.id);
         if (!l_srv_stake) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_NO_STAKE_ERR, "Specified net have no stake service activated");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_NO_STAKE_ERR, "Specified net have no stake service activated");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_NO_STAKE_ERR;
         }
         dap_chain_net_srv_stake_item_t *l_stake = NULL;
         HASH_FIND(hh, l_srv_stake->itemlist, &l_signing_addr.data.hash_fast, sizeof(dap_hash_fast_t), l_stake);
         if (!l_stake) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_CERT_PKEY_ERR, "Specified certificate/pkey hash is not delegated nor this delegating is approved."
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_CERT_PKEY_ERR, "Specified certificate/pkey hash is not delegated nor this delegating is approved."
                                                            " Try to invalidate with tx hash instead");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_CERT_PKEY_ERR;
         }
@@ -2567,13 +2568,13 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
     const char *l_tx_hash_str_tmp = l_tx_hash_str ? l_tx_hash_str : dap_hash_fast_to_str_static(&l_tx_hash);
     dap_chain_datum_tx_t *l_tx = dap_ledger_tx_find_by_hash(l_net->pub.ledger, &l_tx_hash);
     if (!l_tx) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_TX_ERR, "Transaction %s not found", l_tx_hash_str_tmp);
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_TX_ERR, "Transaction %s not found", l_tx_hash_str_tmp);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_TX_ERR;
     }
 
     int l_out_num = 0;
     if (!dap_chain_datum_tx_out_cond_get(l_tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_STAKE_POS_DELEGATE, &l_out_num)) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_TX_ERR, "Transaction %s is invalid", l_tx_hash_str_tmp);
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_TX_ERR, "Transaction %s is invalid", l_tx_hash_str_tmp);
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_INVALID_TX_ERR;
     }
     dap_hash_fast_t l_spender_hash = {};
@@ -2581,14 +2582,14 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
         l_tx_hash = l_spender_hash;
         l_tx_hash_str_tmp = dap_hash_fast_to_str_static(&l_spender_hash);
         if (!dap_ledger_tx_find_by_hash(l_net->pub.ledger, &l_tx_hash)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_PREV_TX_ERR, "Previous transaction %s is not found", l_tx_hash_str_tmp);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_PREV_TX_ERR, "Previous transaction %s is not found", l_tx_hash_str_tmp);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_PREV_TX_ERR;
         }
     }
     if (l_tx_hash_str) {
         dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(l_net->pub.id);
         if (!l_srv_stake) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_NO_STAKE_ERR, "Specified net have no stake service activated");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_NO_STAKE_ERR, "Specified net have no stake service activated");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NET_NO_STAKE_ERR;
         }
         dap_chain_net_srv_stake_item_t *l_stake = NULL;
@@ -2596,7 +2597,7 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
         if (l_stake) {
             char l_pkey_hash_str[DAP_HASH_FAST_STR_SIZE]; 
             dap_hash_fast_to_str(&l_stake->signing_addr.data.hash_fast, l_pkey_hash_str, DAP_HASH_FAST_STR_SIZE);
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_DELEGATED_TX_ERR, "Transaction %s has active delegated key %s, need to revoke it first",
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_DELEGATED_TX_ERR, "Transaction %s has active delegated key %s, need to revoke it first",
                                               l_tx_hash_str_tmp, l_pkey_hash_str);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_DELEGATED_TX_ERR;
         }
@@ -2606,7 +2607,7 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
         const char* l_sign_str = "";
         dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config),NULL);
         if (!l_wallet) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_WALLET_ERR, "Specified wallet not found");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_WALLET_ERR, "Specified wallet not found");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_WALLET_ERR;
         } else {
             l_sign_str = dap_chain_wallet_check_sign(l_wallet);
@@ -2622,23 +2623,23 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
             json_object_object_add(l_json_object_invalidate, "sign", json_object_new_string(l_sign_str));
             json_object_object_add(l_json_object_invalidate, "tx_hash", json_object_new_string(l_out_hash_str));
             json_object_object_add(l_json_object_invalidate, "message", json_object_new_string("All m-tokens successfully returned to owner"));
-            json_object_array_add(*json_arr_reply, l_json_object_invalidate);
+            json_object_array_add(*a_json_arr_reply, l_json_object_invalidate);
             DAP_DELETE(l_out_hash_str);
             DAP_DELETE(l_tx);
         } else {
             l_tx_hash_str = dap_chain_hash_fast_to_str_static(&l_tx_hash);
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_TX_INVALIDATE_ERR, "Can't invalidate transaction %s, examine log files for details", l_tx_hash_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_TX_INVALIDATE_ERR, "Can't invalidate transaction %s, examine log files for details", l_tx_hash_str);
             DAP_DEL_Z(l_tx);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_TX_INVALIDATE_ERR;
         }
     } else {
         dap_cert_t *l_poa_cert = dap_cert_find_by_name(l_poa_cert_str);
         if (!l_poa_cert) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_CERT_ERR, "Specified certificate not found");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_CERT_ERR, "Specified certificate not found");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_NO_CERT_ERR;
         }
         if (!s_srv_stake_is_poa_cert(l_net, l_poa_cert->enc_key)) {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_POA_CERT_ERR, "Specified certificate is not PoA root one");
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_POA_CERT_ERR, "Specified certificate is not PoA root one");
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_POA_CERT_ERR;
         }
         dap_chain_datum_decree_t *l_decree = s_stake_decree_invalidate(l_net, &l_tx_hash, l_poa_cert);
@@ -2649,13 +2650,13 @@ static int s_cli_srv_stake_invalidate(int a_argc, char **a_argv, int a_arg_index
             json_object_object_add(l_json_object_invalidate, "decree", json_object_new_string(l_decree_hash_str));
             json_object_object_add(l_json_object_invalidate, "message", json_object_new_string("Specified delegated key invalidated."
                                                                                                "Try to execute this command with -w to return m-tokens to owner"));
-            json_object_array_add(*json_arr_reply, l_json_object_invalidate);
+            json_object_array_add(*a_json_arr_reply, l_json_object_invalidate);
             DAP_DELETE(l_decree);
             DAP_DELETE(l_decree_hash_str);
         } else {
             char l_tx_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
             dap_chain_hash_fast_to_str(&l_tx_hash, l_tx_hash_str, sizeof(l_tx_hash_str));
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_TX_INVALIDATE_ERR, "Can't invalidate transaction %s, examine log files for details", l_tx_hash_str);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_TX_INVALIDATE_ERR, "Can't invalidate transaction %s, examine log files for details", l_tx_hash_str);
             DAP_DEL_Z(l_decree);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_INVALIDATE_TX_INVALIDATE_ERR;
         }
@@ -2857,7 +2858,7 @@ uint256_t dap_chain_net_srv_stake_get_total_weight(dap_chain_net_id_t a_net_id,
 
 static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
 {
-    json_object **json_arr_reply = (json_object **)a_str_reply;
+    json_object **a_json_arr_reply = (json_object **)a_str_reply;
     enum {
         CMD_NONE, CMD_ORDER, CMD_DELEGATE, CMD_UPDATE, CMD_APPROVE, CMD_LIST, CMD_INVALIDATE, CMD_MIN_VALUE, CMD_CHECK, CMD_MAX_WEIGHT
     };
@@ -2868,7 +2869,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
     if (!l_hash_out_type)
         l_hash_out_type = "hex";
     else if (dap_strcmp(l_hash_out_type," hex") && dap_strcmp(l_hash_out_type, "base58")) {
-        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR,
+        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR,
                                 "Invalid parameter -H, valid values: -H <hex | base58>");
         return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
     }
@@ -2933,49 +2934,49 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &str_tx_hash);
             l_net = dap_chain_net_by_name(l_netst);
             if (!l_net) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_netst);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_netst);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR;
             }
             if (!str_tx_hash) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command check requires parameter -tx");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command check requires parameter -tx");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             if (dap_chain_hash_fast_from_str(str_tx_hash, &l_tx)){
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR, "Can't get hash_fast from %s, check that the hash is correct", str_tx_hash);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR, "Can't get hash_fast from %s, check that the hash is correct", str_tx_hash);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR;
             }
             int res = dap_chain_net_srv_stake_check_validator(l_net, &l_tx, &l_out, 10000, 15000);
             switch (res) {
             case -4:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NEED_TX_NOT_OUTPUT_ERR,"Requested conditional transaction has no required conditional output");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NEED_TX_NOT_OUTPUT_ERR,"Requested conditional transaction has no required conditional output");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NEED_TX_NOT_OUTPUT_ERR;
                 break;
             case -5:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ADDR_ERR,"Can't calculate hash of addr");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ADDR_ERR,"Can't calculate hash of addr");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ADDR_ERR;
                 break;
             case -6:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_NODE_ERR,"Node not found in base");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_NODE_ERR,"Node not found in base");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_NODE_ERR;
                 break;
             case -7:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NODE_BAD_SIZE_ERR,"Node has bad size in base, see log file");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NODE_BAD_SIZE_ERR,"Node has bad size in base, see log file");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NODE_BAD_SIZE_ERR;
                 break;
             case -8:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CON_TO_NODE_ERR,"Can't connect to remote node");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CON_TO_NODE_ERR,"Can't connect to remote node");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CON_TO_NODE_ERR;
                 break;
             case -9:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_RES_FROM_NODE_ERR,"No response from node");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_RES_FROM_NODE_ERR,"No response from node");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_RES_FROM_NODE_ERR;
                 break;
             case -10:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_SEND_PKT_ERR,"Can't send DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY_REQUEST packet");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_SEND_PKT_ERR,"Can't send DAP_STREAM_CH_CHAIN_NET_PKT_TYPE_NODE_VALIDATOR_READY_REQUEST packet");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_SEND_PKT_ERR;
                 break;
             case -11:
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_TX_ERR,"Can't find conditional tx");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_TX_ERR,"Can't find conditional tx");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_TX_ERR;
                 break;
             default:
@@ -2992,7 +2993,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
             json_object_object_add(json_obj_order, "FOUND_CERT", json_object_new_string((l_out.header.flags & F_CERT)?"true":"false"));
             json_object_object_add(json_obj_order, "SIGN_CORRECT", json_object_new_string(l_out.header.sign_correct ?  "true":"false"));
             json_object_object_add(json_obj_order, "SUMMARY", json_object_new_string(l_out.header.overall_correct ? "Validator ready" : "There are unresolved issues"));
-            json_object_array_add(*json_arr_reply, json_obj_order);
+            json_object_array_add(*a_json_arr_reply, json_obj_order);
         }
         break;
 
@@ -3001,48 +3002,48 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
             l_arg_index++;
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
             if (!l_net_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'approve' requires parameter -net");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'approve' requires parameter -net");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
             if (!l_net) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR;
             }
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-poa_cert", &l_cert_str);
             if (!l_cert_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'approve' requires parameter -poa_cert");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'approve' requires parameter -poa_cert");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
             if (!l_cert) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR;
             }
             if (!s_srv_stake_is_poa_cert(l_net, l_cert->enc_key)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR, "Specified certificate is not PoA root one");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR, "Specified certificate is not PoA root one");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR;
             }
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
             if (!l_tx_hash_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'approve' requires parameter -tx");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'approve' requires parameter -tx");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_chain_hash_fast_t l_tx_hash = {};
             if (dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR, "Invalid transaction hash format");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR, "Invalid transaction hash format");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR;
             }
             dap_chain_datum_decree_t *l_decree = dap_chain_net_srv_stake_decree_approve(l_net, &l_tx_hash, l_cert);
             char *l_decree_hash_str = NULL;
             if (!l_decree || !(l_decree_hash_str = s_stake_decree_put(l_decree, l_net))) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_DECREE_ERR, "Approve decree error");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_DECREE_ERR, "Approve decree error");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_DECREE_ERR;
             }
             DAP_DELETE(l_decree);
             char l_approve_str[128] = {'\0'};
             sprintf(l_approve_str,"Approve decree %s successfully created", l_decree_hash_str);
-            json_object_array_add(*json_arr_reply, json_object_new_string(l_approve_str));
+            json_object_array_add(*a_json_arr_reply, json_object_new_string(l_approve_str));
             DAP_DELETE(l_decree_hash_str);
         } break;
 
@@ -3055,17 +3056,17 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                 l_arg_index++;
                 dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
                 if (!l_net_str) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'list keys' requires parameter -net");
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'list keys' requires parameter -net");
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
                 }
                 dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
                 if (!l_net) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR;
                 }
                 dap_chain_net_srv_stake_t *l_srv_stake = s_srv_stake_by_net_id(l_net->pub.id);
                 if (!l_srv_stake) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_STAKE_IN_NET_ERR, "Specified net have no stake service activated");
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_STAKE_IN_NET_ERR, "Specified net have no stake service activated");
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_STAKE_IN_NET_ERR;
                 }
                 dap_chain_net_srv_stake_item_t *l_stake = NULL;
@@ -3073,17 +3074,17 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                 if (l_cert_str) {
                     dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
                     if (!l_cert) {
-                        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
+                        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
                         return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR;
                     }
                     dap_chain_addr_t l_signing_addr;
                     if (dap_chain_addr_fill_from_key(&l_signing_addr, l_cert->enc_key, l_net->pub.id)) {
-                        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_CERT_ERR,"Specified certificate is wrong");
+                        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_CERT_ERR,"Specified certificate is wrong");
                         return DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_CERT_ERR;
                     }
                     HASH_FIND(hh, l_srv_stake->itemlist, &l_signing_addr.data.hash_fast, sizeof(dap_hash_fast_t), l_stake);
                     if (!l_stake) {
-                        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_CERT_ERR, "Specified certificate isn't delegated nor approved");
+                        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_CERT_ERR, "Specified certificate isn't delegated nor approved");
                         return DAP_CHAIN_NODE_CLI_SRV_STAKE_CERT_ERR;
                     }
                 }
@@ -3092,12 +3093,12 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                 if (l_pkey_hash_str) {
                     dap_hash_fast_t l_pkey_hash;
                     if (dap_chain_hash_fast_from_str(l_pkey_hash_str, &l_pkey_hash)) {
-                        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_HASH_ERR, "Specified pkey hash is wrong");
+                        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_HASH_ERR, "Specified pkey hash is wrong");
                         return DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_HASH_ERR;
                     }
                     l_stake = dap_chain_net_srv_stake_check_pkey_hash(l_net->pub.id, &l_pkey_hash);
                     if (!l_stake) {
-                        dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR, "Specified pkey hash isn't delegated nor approved");
+                        dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR, "Specified pkey hash isn't delegated nor approved");
                         return DAP_CHAIN_NODE_CLI_SRV_STAKE_HASH_ERR;
                     }
                 }
@@ -3142,24 +3143,24 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                 }
                 json_object_object_add(l_json_obj_keys_count, "each_validator_max_related_weight", json_object_new_string(IS_ZERO_256(l_percent_max) ? "100" : l_percent_max_str));
                 json_object_array_add(l_json_arr_list, l_json_obj_keys_count);
-                json_object_array_add(*json_arr_reply, l_json_arr_list);
+                json_object_array_add(*a_json_arr_reply, l_json_arr_list);
             } else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "tx", NULL)) {
                 const char *l_net_str = NULL;
                 l_arg_index++;
                 dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
                 if (!l_net_str) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'list tx' requires parameter -net");
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'list tx' requires parameter -net");
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
                 }
                 dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
                 if (!l_net) {
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR;
                 }
                 struct get_tx_cond_pos_del_from_tx * l_args = DAP_NEW_Z(struct get_tx_cond_pos_del_from_tx);
                 if(!l_args) {
                     log_it(L_CRITICAL, "%s", c_error_memory_alloc);
-                    dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_MEMORY_ERR, "Out of memory");
+                    dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_MEMORY_ERR, "Out of memory");
                     return DAP_CHAIN_NODE_CLI_SRV_STAKE_MEMORY_ERR;
                 }
                 json_object * l_json_arr_tx = json_object_new_array();
@@ -3200,10 +3201,10 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                     DAP_DELETE(l_node_address_text_block);
                 }
 
-                json_object_array_add(*json_arr_reply, l_json_arr_tx);
+                json_object_array_add(*a_json_arr_reply, l_json_arr_tx);
                 DAP_DELETE(l_args);
             } else {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_SUB_COMMAND_ERR, "Subcommand '%s' not recognized", a_argv[l_arg_index]);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_SUB_COMMAND_ERR, "Subcommand '%s' not recognized", a_argv[l_arg_index]);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_WRONG_SUB_COMMAND_ERR;
             }
         } break;
@@ -3215,44 +3216,44 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
             l_arg_index++;
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
             if (!l_net_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'min_value' requires parameter -net");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'min_value' requires parameter -net");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
             if (!l_net) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR;
             }
             dap_chain_t *l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR);
             if (!l_chain)
                 l_chain =  dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR);
             if (!l_chain) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ANCHOR_NOT_SUPPORT_ERR, "No chain supported anchor datum type");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ANCHOR_NOT_SUPPORT_ERR, "No chain supported anchor datum type");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_ANCHOR_NOT_SUPPORT_ERR;
             }
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-poa_cert", &l_cert_str);
             if (!l_cert_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'min_value' requires parameter -poa_cert");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'min_value' requires parameter -poa_cert");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_cert_t *l_poa_cert = dap_cert_find_by_name(l_cert_str);
             if (!l_poa_cert) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR;
             }
             if (!s_srv_stake_is_poa_cert(l_net, l_poa_cert->enc_key)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR, "Specified certificate is not PoA root one");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR, "Specified certificate is not PoA root one");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR;
             }
 
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-value", &l_value_str);
             if (!l_value_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'min_value' requires parameter -value");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'min_value' requires parameter -value");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             uint256_t l_value = dap_chain_balance_scan(l_value_str);
             if (IS_ZERO_256(l_value)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Unrecognized number in '-value' param");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Unrecognized number in '-value' param");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
 
@@ -3262,11 +3263,11 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                 json_object* l_json_obj_min_val = json_object_new_object();
                 json_object_object_add(l_json_obj_min_val, "status", json_object_new_string("success"));
                 json_object_object_add(l_json_obj_min_val, "decree_hash", json_object_new_string(l_decree_hash_str));
-                json_object_array_add(*json_arr_reply, l_json_obj_min_val);
+                json_object_array_add(*a_json_arr_reply, l_json_obj_min_val);
                 DAP_DELETE(l_decree);
                 DAP_DELETE(l_decree_hash_str);
             } else {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_MIN_STAKE_SET_FAILED_ERR, "Minimum stake value setting failed");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_MIN_STAKE_SET_FAILED_ERR, "Minimum stake value setting failed");
                 DAP_DEL_Z(l_decree);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_MIN_STAKE_SET_FAILED_ERR;
             }
@@ -3279,48 +3280,48 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
             l_arg_index++;
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
             if (!l_net_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'max_weight' requires parameter -net");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'max_weight' requires parameter -net");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
             if (!l_net) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR, "Network %s not found", l_net_str);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NET_ERR;
             }
             dap_chain_t *l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR);
             if (!l_chain)
                 l_chain =  dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_ANCHOR);
             if (!l_chain) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_ANCHOR_NOT_SUPPORT_ERR, "No chain supported anchor datum type");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_ANCHOR_NOT_SUPPORT_ERR, "No chain supported anchor datum type");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_ANCHOR_NOT_SUPPORT_ERR;
             }
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-poa_cert", &l_cert_str);
             if (!l_cert_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'max_weight' requires parameter -poa_cert");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'max_weight' requires parameter -poa_cert");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             dap_cert_t *l_poa_cert = dap_cert_find_by_name(l_cert_str);
             if (!l_poa_cert) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR, "Specified certificate not found");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NO_CERT_ERR;
             }
             if (!s_srv_stake_is_poa_cert(l_net, l_poa_cert->enc_key)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR, "Specified certificate is not PoA root one");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR, "Specified certificate is not PoA root one");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_NOT_POA_ERR;
             }
 
             dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-percent", &l_value_str);
             if (!l_value_str) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'max_weight' requires parameter -percent");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Command 'max_weight' requires parameter -percent");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             uint256_t l_value = dap_chain_coins_to_balance(l_value_str);
             if (IS_ZERO_256(l_value)) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Unrecognized number in '-percent' param");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR, "Unrecognized number in '-percent' param");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PARAM_ERR;
             }
             if (compare256(l_value, dap_chain_coins_to_balance("100.0")) >= 0) {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_PERCENT_ERR, "Percent must be lower than 100%%");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_PERCENT_ERR, "Percent must be lower than 100%%");
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_PERCENT_ERR;
             }
             DIV_256(l_value, GET_256_FROM_64(100), &l_value);
@@ -3330,18 +3331,18 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, void **a_str_reply)
                 json_object* l_json_obj_max_weight = json_object_new_object();
                 json_object_object_add(l_json_obj_max_weight, "status", json_object_new_string("success"));
                 json_object_object_add(l_json_obj_max_weight, "decree_hash", json_object_new_string(l_decree_hash_str));
-                json_object_array_add(*json_arr_reply, l_json_obj_max_weight);
+                json_object_array_add(*a_json_arr_reply, l_json_obj_max_weight);
                 DAP_DELETE(l_decree);
                 DAP_DELETE(l_decree_hash_str);
             } else {
-                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_MAX_WEIGHT_SET_FAILED_ERR, "Maximum weight setting failed");
+                dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_MAX_WEIGHT_SET_FAILED_ERR, "Maximum weight setting failed");
                 DAP_DEL_Z(l_decree);
                 return DAP_CHAIN_NODE_CLI_SRV_STAKE_MAX_WEIGHT_SET_FAILED_ERR;
             }
         } break;
 
         default: {
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_SRV_STAKE_UNRECOGNIZE_COM_ERR, "Command %s not recognized", a_argv[l_arg_index]);
+            dap_json_rpc_error_add(*a_json_arr_reply, DAP_CHAIN_NODE_CLI_SRV_STAKE_UNRECOGNIZE_COM_ERR, "Command %s not recognized", a_argv[l_arg_index]);
             return DAP_CHAIN_NODE_CLI_SRV_STAKE_UNRECOGNIZE_COM_ERR;
         }
     }