dap-sdk @ b12d9223

-Subproject commit 72ddf0b2f2433f056e8d060accf804d5e37c5803
+Subproject commit b12d92231b4902df2b839bf495dbc7b57bf82c8c

modules/chain/dap_chain.c

@@ -519,7 +519,7 @@ dap_chain_t *dap_chain_load_from_cfg(const char *a_chain_net_name, dap_chain_net
 				} else
 					l_chain->autoproc_datum_types_count = 0;
 			}
-            dap_config_close(l_cfg);
+            l_chain->config = l_cfg;
             return l_chain;
         } else
             return NULL;

modules/chain/include/dap_chain.h

@@ -201,6 +201,8 @@ typedef struct dap_chain {
 
     dap_list_t *atom_notifiers;
 
+    dap_config_t *config;
+
     void * _pvt; // private data
     void * _inheritor; // inheritor object
 } dap_chain_t;

modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c

@@ -330,6 +330,10 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
         return false;
     }
 
+    char l_order_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE] = {};
+    dap_chain_hash_fast_to_str(&a_request->hdr.order_hash, l_order_hash_str, DAP_CHAIN_HASH_FAST_STR_SIZE);
+    log_it(L_MSG, "Got order with hash %s.", l_order_hash_str);
+
     if ( ! l_net ) {
         // Network not found
         log_it( L_ERROR, "Can't find net with id 0x%016"DAP_UINT64_FORMAT_x"", a_request->hdr.srv_uid.uint64);
@@ -398,14 +402,14 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
     l_price = dap_chain_net_srv_get_price_from_order(l_srv, "srv_vpn", &a_request->hdr.order_hash);
     if (!l_price){
         log_it(L_ERROR, "Can't get price from order!");
-            l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_PRICE_NOT_FOUND;
-            if(a_ch)
-                dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
-            if (l_srv && l_srv->callbacks.response_error)
-                l_srv->callbacks.response_error(l_srv, 0, NULL, &l_err, sizeof(l_err));
-            DAP_DEL_Z(l_usage->client);
-            DAP_DEL_Z(l_usage);
-            return false;
+        l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_PRICE_NOT_FOUND;
+        if(a_ch)
+            dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
+        if (l_srv && l_srv->callbacks.response_error)
+            l_srv->callbacks.response_error(l_srv, 0, NULL, &l_err, sizeof(l_err));
+        // DAP_DEL_Z(l_usage->client);
+        // DAP_DEL_Z(l_usage);
+        return false;
     }
 
     if (IS_ZERO_256(l_price->value_datoshi)){
@@ -439,8 +443,8 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
                 dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
             if (l_srv && l_srv->callbacks.response_error)
                 l_srv->callbacks.response_error(l_srv, 0, NULL, &l_err, sizeof(l_err));
-            DAP_DEL_Z(l_usage->client);
-            DAP_DEL_Z(l_usage);
+            // DAP_DEL_Z(l_usage->client);
+            // DAP_DEL_Z(l_usage);
             return false;
         }
         l_grace->request = DAP_DUP_SIZE(a_request, a_request_size);
@@ -451,8 +455,8 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
                 dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
             if (l_srv && l_srv->callbacks.response_error)
                 l_srv->callbacks.response_error(l_srv, 0, NULL, &l_err, sizeof(l_err));
-            DAP_DEL_Z(l_usage->client);
-            DAP_DEL_Z(l_usage);
+            // DAP_DEL_Z(l_usage->client);
+            // DAP_DEL_Z(l_usage);
             DAP_DEL_Z(l_grace);
             return false;
         }
@@ -476,8 +480,8 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
                 dap_stream_ch_pkt_write_unsafe(a_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
             if (l_srv && l_srv->callbacks.response_error)
                 l_srv->callbacks.response_error(l_srv, 0, NULL, &l_err, sizeof(l_err));
-            DAP_DEL_Z(l_usage->client);
-            DAP_DEL_Z(l_usage);
+            // DAP_DEL_Z(l_usage->client);
+            // DAP_DEL_Z(l_usage);
             return false;
         }
         l_success->hdr.usage_id = l_usage->id;

modules/common/dap_chain_datum_decree.c

@@ -177,7 +177,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
         l_offset += dap_tsd_size(l_tsd);
         switch(l_tsd->type) {
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE:
-                if (l_tsd->size > sizeof(uint256_t)){
+                if (l_tsd->size != sizeof(uint256_t)){
                     dap_string_append_printf(a_str_out, "\tValue: <WRONG SIZE>\n");
                     break;
                 }
@@ -189,7 +189,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_SIGN:
             break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE:
-                if (l_tsd->size > sizeof(uint256_t)){
+                if (l_tsd->size != sizeof(uint256_t)){
                     dap_string_append_printf(a_str_out, "\tFee: <WRONG SIZE>\n");
                     break;
                 }
@@ -199,7 +199,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tFee: %s\n", l_fee_value_str);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_OWNER:
-                if (l_tsd->size < sizeof(dap_pkey_t)) {
+                if (l_tsd->size != sizeof(dap_pkey_t)) {
                     dap_string_append_printf(a_str_out, "\tOwner fingerprint: <WRONG SIZE>\n");
                     break;
                 }
@@ -210,7 +210,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tOwner fingerprint: %s\n", l_owner_pkey_str);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_MIN_OWNER:
-                if (l_tsd->size != sizeof(uint32_t)){
+                if (l_tsd->size != sizeof(uint256_t)) {
                     dap_string_append_printf(a_str_out, "\tOwner min: <WRONG SIZE>\n");
                     break;
                 }
@@ -220,7 +220,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tOwner min: %s\n", l_owner_min_str);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_FEE_WALLET:
-                if (l_tsd->size > sizeof(dap_chain_addr_t)) {
+                if (l_tsd->size != sizeof(dap_chain_addr_t)) {
                     dap_string_append_printf(a_str_out, "\tWallet for fee: <WRONG SIZE>\n");
                     break;
                 }
@@ -229,7 +229,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tWallet for fee: %s\n", dap_chain_addr_to_str(l_addr_fee_wallet));
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_HASH:
-                if (l_tsd->size > sizeof(dap_hash_fast_t)) {
+                if (l_tsd->size != sizeof(dap_hash_fast_t)) {
                     dap_string_append_printf(a_str_out, "\tHash: <WRONG SIZE>\n");
                     break;
                 }
@@ -241,7 +241,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tHash: %s\n", l_stake_tx_hash);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_VALUE:
-                if (l_tsd->size > sizeof(uint256_t)){
+                if (l_tsd->size != sizeof(uint256_t)){
                     dap_string_append_printf(a_str_out, "\tStake value: <WRONG SIZE>\n");
                     break;
                 }
@@ -251,7 +251,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tStake value: %s\n", l_stake_value_str);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_SIGNING_ADDR:
-                if (l_tsd->size > sizeof(dap_chain_addr_t)) {
+                if (l_tsd->size != sizeof(dap_chain_addr_t)) {
                     dap_string_append_printf(a_str_out, "\tSigning addr: <WRONG SIZE>\n");
                     break;
                 }
@@ -265,7 +265,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tSigning pkey fingerprint: %s\n", l_pkey_signing_str);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_NODE_ADDR:
-                if(l_tsd->size > sizeof(dap_chain_node_addr_t)){
+                if (l_tsd->size != sizeof(dap_chain_node_addr_t)){
                     dap_string_append_printf(a_str_out, "\tNode addr: <WRONG SIZE>\n");
                     break;
                 }
@@ -274,7 +274,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                                          NODE_ADDR_FP_ARGS(l_node_addr));
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_VALUE:
-                if (l_tsd->size > sizeof(uint256_t)) {
+                if (l_tsd->size != sizeof(uint256_t)) {
                     dap_string_append_printf(a_str_out, "\tMin value: <WRONG SIZE>\n");
                     break;
                 }
@@ -284,7 +284,7 @@ void dap_chain_datum_decree_dump(dap_string_t *a_str_out, dap_chain_datum_decree
                 dap_string_append_printf(a_str_out, "\tMin value: %s\n", l_min_value_str);
                 break;
             case DAP_CHAIN_DATUM_DECREE_TSD_TYPE_STAKE_MIN_SIGNERS_COUNT:
-                if (l_tsd->size > sizeof(uint256_t)) {
+                if (l_tsd->size != sizeof(uint256_t)) {
                     dap_string_append_printf(a_str_out, "\tMin signers count: <WRONG SIZE>\n");
                     break;
                 }

modules/consensus/esbocs/dap_chain_cs_esbocs.c

@@ -192,9 +192,9 @@ int dap_chain_cs_esbocs_init()
             "\tEnables or disables checks for blocks signs structure validity\n"
         "esbocs check_signs_structure show -net <net_name> -chain <chain_name>\n"
             "\tShow status of checks for blocks signs structure validity\n"
-        "esbocs emergency_validator {add|remove} -net <net_name> -chain <chain_name> -cert <poa_cert_name> -pkey_hash <validator_pkey_hash>\n"
+        "esbocs emergency_validators {add|remove} -net <net_name> -chain <chain_name> -cert <poa_cert_name> -pkey_hash <validator_pkey_hash>\n"
             "\tAdd or remove validator by its signature public key hash to list of validators allowed to work in emergency mode\n"
-        "esbocs emergency_validator show -net <net_name> -chain <chain_name>\n"
+        "esbocs emergency_validators show -net <net_name> -chain <chain_name>\n"
             "\tShow list of validators public key hashes allowed to work in emergency mode\n");
     return 0;
 }
@@ -2989,7 +2989,7 @@ static int s_cli_esbocs(int a_argc, char **a_argv, void **a_str_reply)
         [SUBCMD_UNDEFINED] = NULL,
         [SUBCMD_MIN_VALIDATORS_COUNT] = "min_validators_count",
         [SUBCMD_CHECK_SIGNS_STRUCTURE] = "check_signs_structure",
-        [SUBCMD_EMERGENCY_VALIDATOR] = "emergency_validator",
+        [SUBCMD_EMERGENCY_VALIDATOR] = "emergency_validators",
     };
 
     const size_t l_subcmd_str_count = sizeof(l_subcmd_strs) / sizeof(char *);
@@ -3120,7 +3120,7 @@ static int s_cli_esbocs(int a_argc, char **a_argv, void **a_str_reply)
     } break;
 
     default:
-        dap_cli_server_cmd_set_reply_text(a_str_reply, "Unrecognized subcommand '%s'", a_argv[l_arg_index]);
+        dap_cli_server_cmd_set_reply_text(a_str_reply, "Unrecognized subcommand '%s'", a_argv[l_arg_index - 1]);
     }
     return ret;
 }

modules/net/dap_chain_net.c

@@ -1839,7 +1839,7 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
         dap_config_close(l_cfg);
         return -1;
     }
-    
+
     l_net->pub.gdb_groups_prefix = dap_strdup(
                 dap_config_get_item_str_default(l_cfg, "general", "gdb_groups_prefix",
                                                 dap_config_get_item_str(l_cfg, "general", "name")));
@@ -2077,6 +2077,8 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
     // Decrees initializing
     dap_chain_net_decree_init(l_net);
 
+    l_net->pub.config = l_cfg;
+
     return 0;
 }
 
@@ -2265,7 +2267,7 @@ bool s_net_load(void *a_arg)
             l_chain->callback_created(l_chain, l_cfg);
 
      if ( dap_config_get_item_bool_default(g_config, "server", "enabled", false) ) {
-        if ( !l_net_pvt->node_info ) {
+        if ( !l_net_pvt->node_info->ext_port ) {
             char l_host[DAP_HOSTADDR_STRLEN + 1] = { '\0' };
             uint16_t l_ext_port = 0;
             const char *l_ext_addr = dap_config_get_item_str_default(g_config, "server", "ext_address", NULL);

modules/net/dap_chain_net_balancer.c

@@ -46,6 +46,7 @@ typedef struct dap_balancer_link_request {
 
 static_assert(sizeof(dap_chain_net_links_t) + sizeof(dap_chain_node_info_old_t) < DAP_BALANCER_MAX_REPLY_SIZE, "DAP_BALANCER_MAX_REPLY_SIZE cannot accommodate information minimum about 1 link");
 static const size_t s_max_links_response_count = (DAP_BALANCER_MAX_REPLY_SIZE - sizeof(dap_chain_net_links_t)) / sizeof(dap_chain_node_info_old_t);
+static const dap_time_t s_request_period = 5; // sec
 
 /**
  * @brief forming json file with balancer info: class networkName nodeAddress hostAddress hostPort
@@ -78,19 +79,23 @@ static dap_chain_net_links_t *s_get_ignored_node_addrs(dap_chain_net_t *a_net, s
         l_size = 0,
         l_uplinks_count = 0,
         l_low_availability_count = 0;
-    dap_stream_node_addr_t *l_uplinks = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, NULL, true);
-    dap_stream_node_addr_t *l_low_availability = dap_link_manager_get_ignored_addrs(&l_low_availability_count);
-    if(!l_uplinks && !l_low_availability) {
+    const dap_stream_node_addr_t
+        *l_curr_addr = &dap_chain_net_get_my_node_info(a_net)->address,
+        *l_uplinks = dap_link_manager_get_net_links_addrs(a_net->pub.id.uint64, &l_uplinks_count, NULL, true),
+        *l_low_availability = dap_link_manager_get_ignored_addrs(&l_low_availability_count);
+    if(!l_curr_addr->uint64 && !l_uplinks && !l_low_availability) {
+        log_it(L_WARNING, "Error forming ignore list, please check, should be minimum self addr");
         return NULL;
     }
-    l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_uplinks_count + l_low_availability_count);
+    l_size = sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * (l_uplinks_count + l_low_availability_count + 1);
 // memory alloc
     dap_chain_net_links_t *l_ret = NULL;
-    DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, NULL);
+    DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_chain_net_links_t, l_size, NULL, l_uplinks, l_low_availability);
 // func work
-    memcpy(l_ret->nodes_info, l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
-    memcpy(l_ret->nodes_info + l_uplinks_count, l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
-    l_ret->count_node = l_uplinks_count + l_low_availability_count;
+    memcpy(l_ret->nodes_info, l_curr_addr, sizeof(dap_stream_node_addr_t));
+    memcpy(l_ret->nodes_info + sizeof(dap_stream_node_addr_t), l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
+    memcpy(l_ret->nodes_info + (l_uplinks_count + 1) * sizeof(dap_stream_node_addr_t), l_low_availability, l_low_availability_count * sizeof(dap_stream_node_addr_t));
+    l_ret->count_node = l_uplinks_count + l_low_availability_count + 1;
     if (a_size)
         *a_size = l_size;
     DAP_DEL_MULTY(l_uplinks, l_low_availability);
@@ -283,8 +288,8 @@ static dap_chain_net_links_t *s_balancer_issue_link(const char *a_net_name, uint
     if (l_ignored_size) {
         DAP_NEW_Z_SIZE_RET_VAL(l_ignored_dec, dap_chain_net_links_t, l_ignored_size, NULL, NULL);
         dap_enc_base64_decode(a_ignored_enc, l_ignored_size, l_ignored_dec, DAP_ENC_DATA_TYPE_B64);
-        if (l_ignored_size < DAP_ENC_BASE64_ENCODE_SIZE(sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node)) {
-            log_it(L_ERROR, "Cant't decode ignored node list, %zu %zu", l_ignored_size, DAP_ENC_BASE64_ENCODE_SIZE(sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node));
+        if (l_ignored_size < DAP_ENC_BASE64_ENCODE_SIZE((sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node))) {
+            log_it(L_ERROR, "Can't decode ignored node list, received size %zu < expected size %zu", l_ignored_size, DAP_ENC_BASE64_ENCODE_SIZE((sizeof(dap_chain_net_links_t) + sizeof(dap_stream_node_addr_t) * l_ignored_dec->count_node)));
             DAP_DEL_Z(l_ignored_dec);
         }
     }
@@ -293,6 +298,14 @@ static dap_chain_net_links_t *s_balancer_issue_link(const char *a_net_name, uint
     return l_ret;
 }
 
+/**
+ * @brief balancer deinit
+ */
+void dap_chain_net_balancer_deinit()
+{
+
+}
+
 /**
  * @brief balancer handshake
  * @param a_node_info
@@ -402,23 +415,31 @@ int dap_chain_net_balancer_request(dap_chain_net_t *a_net, const char *a_host_ad
 // sanity check
     dap_return_val_if_pass(!a_net, -1);
 // func work
-    size_t l_ignored_addrs_size = 0; // prepare list of the ignored addrs
-    dap_chain_net_links_t *l_ignored_addrs = s_get_ignored_node_addrs(a_net, &l_ignored_addrs_size);
-    size_t l_required_links_count = dap_link_manager_needed_links_count(a_net->pub.id.uint64);
-    // links from local GDB
-    dap_chain_net_links_t *l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);
+    // request each 5 sec
+    static dap_time_t l_last_time = 0;
+    if (dap_time_now() - l_last_time < s_request_period) {
+        log_it(L_DEBUG, "Who understands life, he is in no hurry");
+        return 0;
+    }
+    l_last_time = dap_time_now();
+    size_t
+        l_ignored_addrs_size = 0,
+        l_required_links_count = dap_link_manager_needed_links_count(a_net->pub.id.uint64);
+    dap_chain_net_links_t
+        *l_ignored_addrs = s_get_ignored_node_addrs(a_net, &l_ignored_addrs_size),
+        *l_links = s_get_node_addrs(a_net, l_required_links_count, l_ignored_addrs, false);     // links from local GDB
     if (l_links) {
         s_balancer_link_prepare_success(a_net, l_links, NULL, 0);
         if (l_links->count_node >= l_required_links_count) {
             DAP_DEL_MULTY(l_ignored_addrs, l_links);
             return 0;
         }
-        else
-            l_required_links_count -= l_links->count_node;
+        l_required_links_count -= l_links->count_node;
         DAP_DELETE(l_links);
     }
     if (!a_host_addr || !a_host_port) {
         log_it(L_INFO, "Can't read seed nodes addresses, work with local balancer only");
+        DAP_DEL_Z(l_ignored_addrs);
         return 0;
     }
     // dynamic links from http balancer request

modules/net/dap_chain_net_node_list.c

@@ -302,8 +302,7 @@ int dap_chain_net_node_list_request(dap_chain_net_t *a_net, uint16_t a_port, boo
             }
         }
     }
-    DAP_DELETE(l_request);
-    DAP_DELETE(l_seeds_addrs);
+    DAP_DEL_MULTY(l_request, l_seeds_addrs);
     s_node_list_request_deinit(l_link_node_request);
     return l_ret;
 }

modules/net/dap_chain_node_cli_cmd.c

@@ -103,7 +103,6 @@
 #include "dap_json_rpc_errors.h"
 #include "dap_http_ban_list_client.h"
 #include "dap_chain_datum_tx_voting.h"
-#include "dap_enc_ks.h"
 
 
 #define LOG_TAG "chain_node_cli_cmd"

modules/net/include/dap_chain_net.h

@@ -73,6 +73,7 @@ typedef struct dap_chain_net{
         dap_chain_addr_t fee_addr;
         
         dap_list_t *bridged_networks;   // List of bridged network ID's allowed to cross-network TX
+        dap_config_t *config;
     } pub;
     uint8_t pvt[];
 } dap_chain_net_t;

modules/net/include/dap_chain_net_balancer.h

@@ -49,7 +49,7 @@ DAP_STATIC_INLINE const char *dap_chain_net_balancer_type_to_str(dap_balancer_ty
         default: return "UNDEFINED";
     }
 }
-
+void dap_chain_net_balancer_deinit();
 void dap_chain_net_balancer_http_issue_link(dap_http_simple_t *a_http_simple, void *a_arg);
 dap_link_info_t *dap_chain_net_balancer_dns_issue_link(const char *a_net_name);
 int dap_chain_net_balancer_handshake(dap_chain_node_info_t *a_node_info, dap_chain_net_t * a_net);

modules/net/srv/dap_chain_net_srv.c

@@ -410,8 +410,7 @@ static int s_cli_net_srv( int argc, char **argv, void **a_str_reply)
             } else if(!dap_strcmp( l_order_str, "dump" )) {
                 // Select with specified service uid
                 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_hex_str );
-                    if (l_order) {
+                    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_chain_net_srv_order_dump_to_string(l_order,l_string_ret, l_hash_out_type, l_net->pub.native_ticker);
                         l_ret = 0;
                     }else{
@@ -446,6 +445,7 @@ static int s_cli_net_srv( int argc, char **argv, void **a_str_reply)
                 }
             } else if (!dap_strcmp(l_order_str, "delete")) {
                 if (l_order_hash_str) {
+                    
                     l_ret = dap_chain_net_srv_order_delete_by_hash_str_sync(l_net, l_order_hash_hex_str);
                     if (!l_ret)
                         dap_string_append_printf(l_string_ret, "Deleted order %s\n", l_order_hash_str);

modules/net/srv/dap_chain_net_srv_order.c

@@ -429,6 +429,11 @@ dap_chain_net_srv_order_t *dap_chain_net_srv_order_find_by_hash_str(dap_chain_ne
             return NULL;
         }
         l_order = dap_chain_net_srv_order_read(l_gdb_order, l_order_size);
+        if (!l_order || (l_order->ts_expires &&  l_order->ts_expires < dap_time_now())){
+            DAP_DEL_Z(l_order);
+            DAP_DELETE(l_gdb_order);
+            continue;
+        }
         DAP_DELETE(l_gdb_order);
     }
     return l_order;
@@ -472,31 +477,49 @@ int dap_chain_net_srv_order_find_all_by(dap_chain_net_t * a_net,const dap_chain_
                 dap_global_db_del_sync(l_gdb_group_str, l_orders[i].key);
                 continue; // order is corrupted
             }
+            if (l_order->ts_expires && l_order->ts_expires < dap_time_now()){
+                DAP_DEL_Z(l_order);
+                continue;
+            }
+
             dap_chain_hash_fast_t l_hash, l_hash_gdb;
             dap_hash_fast(l_orders[i].value, l_orders[i].value_len, &l_hash);
             dap_chain_hash_fast_from_str(l_orders[i].key, &l_hash_gdb);
             if (memcmp(&l_hash, &l_hash_gdb, sizeof(dap_chain_hash_fast_t))) {
                 dap_global_db_del_sync(l_gdb_group_str, l_orders[i].key);
+                DAP_DEL_Z(l_order);
                 continue; // order is corrupted
             }
             // Check direction
-            if (a_direction != SERV_DIR_UNDEFINED && l_order->direction != a_direction)
+            if (a_direction != SERV_DIR_UNDEFINED && l_order->direction != a_direction){
+                DAP_DEL_Z(l_order);
                 continue;
+            }
             // Check srv uid
-            if (a_srv_uid.uint64 && l_order->srv_uid.uint64 != a_srv_uid.uint64)
+            if (a_srv_uid.uint64 && l_order->srv_uid.uint64 != a_srv_uid.uint64){
+                DAP_DEL_Z(l_order);
                 continue;
+            }
             // check price unit
-            if (a_price_unit.uint32 && a_price_unit.uint32 != l_order->price_unit.uint32)
+            if (a_price_unit.uint32 && a_price_unit.uint32 != l_order->price_unit.uint32){
+                DAP_DEL_Z(l_order);
                 continue;
+            }
             // Check price minimum
-            if (!IS_ZERO_256(a_price_min) && compare256(l_order->price, a_price_min) == -1)
+            if (!IS_ZERO_256(a_price_min) && compare256(l_order->price, a_price_min) == -1){
+                DAP_DEL_Z(l_order);
                 continue;
+            }
             // Check price maximum
-            if (!IS_ZERO_256(a_price_max) && compare256(l_order->price, a_price_max) == 1)
+            if (!IS_ZERO_256(a_price_max) && compare256(l_order->price, a_price_max) == 1){
+                DAP_DEL_Z(l_order);
                 continue;
+            }
             // Check ticker
-            if (a_price_ticker && strcmp( l_order->price_ticker, a_price_ticker))
+            if (a_price_ticker && strcmp( l_order->price_ticker, a_price_ticker)){
+                DAP_DEL_Z(l_order);
                 continue;
+            }
             size_t l_order_mem_size = dap_chain_net_srv_order_get_size(l_order);
             dap_chain_net_srv_order_t *l_output_order = DAP_DUP_SIZE(l_order, l_order_mem_size);
             DAP_DEL_Z(l_order);
@@ -520,13 +543,14 @@ int dap_chain_net_srv_order_find_all_by(dap_chain_net_t * a_net,const dap_chain_
 int dap_chain_net_srv_order_delete_by_hash_str_sync(dap_chain_net_t *a_net, const char *a_hash_str)
 {
     int l_ret = -2;
+
+    dap_chain_net_srv_order_t *l_order = NULL;
     for (int i = 0; a_net && a_hash_str && i < 2; i++) {
         char *l_gdb_group_str = i ? dap_chain_net_srv_order_get_gdb_group(a_net)
                                   : dap_chain_net_srv_order_get_common_group(a_net);
-        l_ret = dap_global_db_del_sync(l_gdb_group_str, a_hash_str);
+
+        int l_ret = dap_global_db_del_sync(l_gdb_group_str, a_hash_str);
         DAP_DELETE(l_gdb_group_str);
-        if (!l_ret)
-            break;
     }
     return l_ret;
 }

modules/net/srv/include/dap_chain_net_srv_order.h

@@ -114,7 +114,7 @@ int dap_chain_net_srv_order_delete_by_hash_str_sync(dap_chain_net_t *a_net, cons
  * @param a_hash
  * @return
  */
-DAP_STATIC_INLINE int dap_chain_net_srv_order_delete_by_hash(dap_chain_net_t * a_net, dap_chain_hash_fast_t * a_hash )
+DAP_STATIC_INLINE int dap_chain_net_srv_order_delete_by_hash(dap_chain_net_t * a_net, dap_chain_hash_fast_t * a_hash)
 {
     char l_hash_str[DAP_CHAIN_HASH_FAST_SIZE * 2 + 4];
     dap_chain_hash_fast_to_str(a_hash,l_hash_str,sizeof(l_hash_str)-1);

modules/service/xchange/dap_chain_net_srv_xchange.c

@@ -2769,11 +2769,8 @@ dap_chain_net_srv_xchange_purchase_error_t dap_chain_net_srv_xchange_purchase(da
         // Create conditional transaction
         char *l_ret = NULL;
         dap_chain_datum_tx_t *l_tx = s_xchange_tx_create_exchange(l_price, a_wallet, a_value, a_fee);
-        if (l_tx && (l_ret = s_xchange_tx_put(l_tx, a_net)) &&
-            dap_hash_fast_is_blank(&l_price->order_hash)) {
-            char *l_order_hash_str = dap_hash_fast_to_str_new(a_order_hash);
-            dap_chain_net_srv_order_delete_by_hash_str_sync(l_price->net, l_order_hash_str);
-            DAP_DELETE(l_order_hash_str);
+        if (l_tx && !dap_hash_fast_is_blank(&l_price->order_hash)) {
+            l_ret = s_xchange_tx_put(l_tx, a_net);
         }
         DAP_DELETE(l_price);
         if (l_tx && l_ret){

modules/type/blocks/dap_chain_cs_blocks.c

@@ -663,7 +663,15 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
         }break;
 
         case SUBCMD_DUMP:{
+            const char *l_hash_out_type = NULL;
             dap_chain_hash_fast_t l_block_hash={0};
+            dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+            if(!l_hash_out_type)
+                l_hash_out_type = "hex";
+            if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
+                dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR, "invalid parameter -H, valid values: -H <hex | base58>");
+                return DAP_CHAIN_NODE_CLI_COM_BLOCK_PARAM_ERR;
+            }
             if (!l_subcmd_str_arg) {
                 dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_HASH_ERR, "Enter block hash ");
                 return DAP_CHAIN_NODE_CLI_COM_BLOCK_HASH_ERR;