From 9f88247c0944d874f0086b4f9e80cb8c2833d8c9 Mon Sep 17 00:00:00 2001
From: "oljas.jarasbaev" <oljas.jarasbaev@demlabs.net>
Date: Tue, 18 Jun 2024 09:49:18 +0000
Subject: [PATCH] Bugfix 10751

---
 dap-sdk                                       |  2 +-
 modules/chain/dap_chain.c                     |  3 +-
 modules/chain/dap_chain_ch.c                  |  6 ++++
 .../dap_stream_ch_chain_net_srv.c             |  7 ++--
 .../consensus/esbocs/dap_chain_cs_esbocs.c    | 10 ++++--
 .../esbocs/include/dap_chain_cs_esbocs.h      | 32 +++++++++----------
 modules/net/dap_chain_ledger.c                | 26 ++++++++-------
 modules/net/dap_chain_net.c                   |  1 -
 modules/net/dap_chain_net_balancer.c          |  6 ++--
 modules/net/dap_chain_node_cli_cmd.c          | 12 ++++---
 modules/net/srv/dap_chain_net_srv.c           |  1 -
 modules/net/srv/dap_chain_net_srv_order.c     |  2 +-
 .../service/datum/dap_chain_net_srv_datum.c   |  8 +++--
 .../stake/dap_chain_net_srv_stake_lock.c      |  4 +--
 modules/service/vpn/dap_chain_net_srv_vpn.c   |  4 +--
 .../service/vpn/dap_chain_net_vpn_client.c    |  2 +-
 .../vpn/dap_chain_net_vpn_client_tun.c        |  3 +-
 .../xchange/dap_chain_net_srv_xchange.c       | 14 ++++++++
 modules/type/blocks/dap_chain_block_cache.c   |  1 +
 modules/type/blocks/dap_chain_cs_blocks.c     | 29 ++++++++++++++---
 modules/type/dag/dap_chain_cs_dag.c           |  4 +--
 21 files changed, 118 insertions(+), 59 deletions(-)

diff --git a/dap-sdk b/dap-sdk
index 9c56451a4c..0edcf99d6e 160000
--- a/dap-sdk
+++ b/dap-sdk
@@ -1 +1 @@
-Subproject commit 9c56451a4c0fcb4adc127868418120ea29681849
+Subproject commit 0edcf99d6ebccfd95abea2c04d95cba593bfb918
diff --git a/modules/chain/dap_chain.c b/modules/chain/dap_chain.c
index d0171a36e1..69aa6c009b 100644
--- a/modules/chain/dap_chain.c
+++ b/modules/chain/dap_chain.c
@@ -523,7 +523,8 @@ 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;
 			}
-            l_chain->config = l_cfg;
+            if (l_chain && l_chain->config)
+                l_chain->config = l_cfg;
             return l_chain;
         } else
             return NULL;
diff --git a/modules/chain/dap_chain_ch.c b/modules/chain/dap_chain_ch.c
index 624617f17e..436d2be1fd 100644
--- a/modules/chain/dap_chain_ch.c
+++ b/modules/chain/dap_chain_ch.c
@@ -1235,9 +1235,11 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
         l_args->pkt = DAP_DUP_SIZE(l_pkt, l_chain_pkt_data_size);
         if (!l_args->pkt) {
             log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+            DAP_DEL_Z(l_args);
             dap_stream_ch_write_error_unsafe(a_ch, l_chain_pkt->hdr.net_id,
                     l_chain_pkt->hdr.chain_id, l_chain_pkt->hdr.cell_id,
                     DAP_CHAIN_CH_ERROR_OUT_OF_MEMORY);
+
             break;
         }
         l_args->worker = a_ch->stream_worker;
@@ -1531,6 +1533,10 @@ static bool s_stream_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
 static bool s_sync_timer_callback(void *a_arg)
 {
     dap_worker_t *l_worker = dap_worker_get_current();
+    if (!l_worker) {
+        DAP_DELETE(a_arg);
+        return false;
+    }
     dap_stream_ch_t *l_ch = dap_stream_ch_find_by_uuid_unsafe(DAP_STREAM_WORKER(l_worker), *(dap_stream_ch_uuid_t *)a_arg);
     if (!l_ch) {
         DAP_DELETE(a_arg);
diff --git a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
index 86ad365619..50e722e2c2 100644
--- a/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
+++ b/modules/channel/chain-net-srv/dap_stream_ch_chain_net_srv.c
@@ -130,6 +130,7 @@ static inline void s_grace_error(dap_chain_net_srv_grace_t *a_grace, dap_stream_
                 l_item = DAP_NEW_Z(dap_chain_net_srv_banlist_item_t);
                 if (!l_item) {
                     log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+                    pthread_mutex_unlock(&a_grace->usage->service->banlist_mutex);
                     DAP_DEL_Z(a_grace->request);
                     DAP_DEL_Z(a_grace);
                     return;
@@ -355,8 +356,8 @@ static bool s_service_start(dap_stream_ch_t* a_ch , dap_stream_ch_chain_net_srv_
     if ( l_err.code || !l_srv_session){
         debug_if(
             l_check_role, L_ERROR,
-            "You can't provide service with ID %lu in net %s. Node role should be not lower than master\n",
-            l_srv->uid.uint64, l_net->pub.name
+            "You can't provide service with ID %llu in net %s. Node role should be not lower than master\n", l_srv ?
+            l_srv->uid.uint64 : 0, l_net->pub.name
             );
         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));
@@ -592,6 +593,7 @@ static bool s_grace_period_start(dap_chain_net_srv_grace_t *a_grace)
                                                                                   l_success_size);
             if(!l_success) {
                 log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+                DAP_DEL_Z(l_item);
                 l_err.code = DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR_CODE_ALLOC_MEMORY_ERROR;
                 if(l_ch)
                     dap_stream_ch_pkt_write_unsafe(l_ch, DAP_STREAM_CH_CHAIN_NET_SRV_PKT_TYPE_RESPONSE_ERROR, &l_err, sizeof (l_err));
@@ -1116,6 +1118,7 @@ static bool s_grace_period_finish(dap_chain_net_srv_grace_usage_t *a_grace_item)
                 l_grace_new->request = DAP_NEW_Z_SIZE(dap_stream_ch_chain_net_srv_pkt_request_t, sizeof(dap_stream_ch_chain_net_srv_pkt_request_t));
                 if (!l_grace_new->request) {
                     log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+                    DAP_DEL_Z(l_grace_new);
                     RET_WITH_DEL_A_GRACE(0);
                 }
                 l_grace_new->request->hdr.net_id = a_grace_item->grace->usage->net->pub.id;
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 366b55415d..890e3b43eb 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -1270,6 +1270,10 @@ static void s_session_state_change(dap_chain_esbocs_session_t *a_session, enum s
                 break;
             }
         }
+        if (!l_validator) {
+            log_it(L_CRITICAL, "l_validator is NULL");
+            break;
+        }
         a_session->cur_round.attempt_submit_validator = l_validator->signing_addr;
         if (dap_chain_addr_compare(&a_session->cur_round.attempt_submit_validator, &a_session->my_signing_addr)) {
             dap_chain_esbocs_directive_t *l_directive = NULL;
@@ -1325,7 +1329,8 @@ static void s_session_state_change(dap_chain_esbocs_session_t *a_session, enum s
                 const char *l_addr = dap_chain_hash_fast_to_str_static(&a_session->cur_round.attempt_submit_validator.data.hash_fast);
                 log_it(L_MSG, "Error: can't find current attmempt submit validator %s in signers list", l_addr);
             }
-            l_validator->is_chosen = false;
+            if (l_validator && l_validator->is_chosen)
+                l_validator->is_chosen = false;
         } else
             a_session->old_state = DAP_CHAIN_ESBOCS_SESSION_STATE_WAIT_PROC;
     } break;
@@ -1773,7 +1778,7 @@ void s_session_sync_queue_add(dap_chain_esbocs_session_t *a_session, dap_chain_e
     dap_chain_esbocs_sync_item_t *l_sync_item;
     HASH_FIND(hh, a_session->sync_items, &a_message->hdr.candidate_hash, sizeof(dap_hash_fast_t), l_sync_item);
     if (!l_sync_item) {
-        DAP_NEW_Z_RET(l_sync_item, dap_chain_esbocs_sync_item_t, NULL);
+        DAP_NEW_Z_RET(l_sync_item, dap_chain_esbocs_sync_item_t, l_message_copy);
         l_sync_item->last_block_hash = a_message->hdr.candidate_hash;
         HASH_ADD(hh, a_session->sync_items, last_block_hash, sizeof(dap_hash_fast_t), l_sync_item);
     }
@@ -2677,6 +2682,7 @@ static void s_message_send(dap_chain_esbocs_session_t *a_session, uint8_t a_mess
                                                           sizeof(struct esbocs_msg_args) + l_message_size + l_sign_size);
             if (!l_args) {
                 log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+                DAP_DELETE(l_message);
                 return;
             }
             l_args->addr_from = a_session->my_addr;
diff --git a/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h b/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
index fc2c218bdf..594c9d9e7e 100644
--- a/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
+++ b/modules/consensus/esbocs/include/dap_chain_cs_esbocs.h
@@ -136,32 +136,30 @@ typedef struct dap_chain_esbocs_directive {
 } DAP_ALIGN_PACKED dap_chain_esbocs_directive_t;
 
 typedef struct dap_chain_esbocs_round {
-    // Base fields
     uint64_t id;
-    uint8_t attempt_num;
+    uint64_t sync_attempt;
+
     dap_hash_fast_t last_block_hash;
-    // Round store
+    dap_hash_fast_t directive_hash;
+    dap_hash_fast_t attempt_candidate_hash;
+    dap_chain_addr_t attempt_submit_validator;
+
+    dap_list_t *all_validators;
     dap_chain_esbocs_store_t *store_items;
     dap_chain_esbocs_message_item_t *message_items;
-    // Round directive
-    dap_hash_fast_t directive_hash;
     dap_chain_esbocs_directive_t *directive;
-    bool directive_applied;
+    uint16_t *excluded_list;
+    dap_list_t *validators_list;
+
+
     uint16_t votes_for_count;
     uint16_t votes_against_count;
-    // Attempt dependent fields
-    dap_chain_addr_t attempt_submit_validator;
-    dap_hash_fast_t attempt_candidate_hash;
-    // Validators section
-    dap_list_t *validators_list;
     uint16_t validators_synced_count;
-    uint16_t *excluded_list;
-    // Synchronization params
-    uint64_t sync_attempt;
-    bool sync_sent;
-    // Check validators online & wide consensus sync
-    dap_list_t *all_validators;
     uint16_t total_validators_synced;
+
+    bool directive_applied;
+    bool sync_sent;
+    uint8_t attempt_num;
 } dap_chain_esbocs_round_t;
 
 typedef struct dap_chain_esbocs_validator {
diff --git a/modules/net/dap_chain_ledger.c b/modules/net/dap_chain_ledger.c
index fe3ba367a3..09dbcc62be 100644
--- a/modules/net/dap_chain_ledger.c
+++ b/modules/net/dap_chain_ledger.c
@@ -1633,6 +1633,7 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_ledger_token_item_t *a
                     // Check if its correct
                     dap_chain_addr_t * l_add_addr = (dap_chain_addr_t *) l_tsd->data;
                     if (dap_chain_addr_check_sum(l_add_addr)) {
+                        DAP_DEL_Z(l_addrs);
                         debug_if(s_debug_more, L_ERROR, "Wrong address checksum in TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD");
                         return -12;
                     }
@@ -1715,6 +1716,7 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_ledger_token_item_t *a
                     // Check if its correct
                     dap_chain_addr_t * l_add_addr = (dap_chain_addr_t *) l_tsd->data;
                     if (dap_chain_addr_check_sum(l_add_addr)) {
+                        DAP_DEL_Z(l_addrs);
                         debug_if(s_debug_more, L_ERROR, "Wrong address checksum in TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD");
                         return -12;
                     }
@@ -1794,6 +1796,7 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_ledger_token_item_t *a
                     // Check if its correct
                     dap_chain_addr_t * l_add_addr = (dap_chain_addr_t *) l_tsd->data;
                     if (dap_chain_addr_check_sum(l_add_addr)) {
+                        DAP_DEL_Z(l_addrs);
                         debug_if(s_debug_more, L_ERROR, "Wrong address checksum in TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD");
                         return -12;
                     }
@@ -2271,7 +2274,6 @@ json_object *dap_ledger_token_info(dap_ledger_t *a_ledger, size_t a_limit, size_
         i_tmp++;
         json_obj_datum = json_object_new_object();
         const char *l_type_str;
-        const char *l_flags_str = s_flag_str_from_code(l_token_item->datum_token->header_private_decl.flags);
         switch (l_token_item->type) {
             case DAP_CHAIN_DATUM_TOKEN_TYPE_DECL: {
                 switch (l_token_item->subtype) {
@@ -4351,7 +4353,6 @@ int dap_ledger_tx_cache_check(dap_ledger_t *a_ledger,
 
                 // 5a. Check for condition owner
                 dap_chain_tx_sig_t *l_tx_prev_sig = (dap_chain_tx_sig_t *)dap_chain_datum_tx_item_get(l_tx_prev, NULL, TX_ITEM_TYPE_SIG, NULL);
-                dap_sign_t *l_prev_sign = dap_chain_datum_tx_item_sign_get_sig((dap_chain_tx_sig_t *)l_tx_prev_sig);
                 dap_chain_tx_sig_t *l_tx_sig = (dap_chain_tx_sig_t *)dap_chain_datum_tx_item_get(a_tx, NULL, TX_ITEM_TYPE_SIG, NULL);
                 dap_sign_t *l_sign = dap_chain_datum_tx_item_sign_get_sig((dap_chain_tx_sig_t *)l_tx_sig);
                 dap_chain_tx_sig_t *l_owner_tx_sig = (dap_chain_tx_sig_t *)dap_chain_datum_tx_item_get(l_owner_tx, NULL, TX_ITEM_TYPE_SIG, NULL);
@@ -4874,7 +4875,7 @@ int dap_ledger_tx_add(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap_ha
     dap_store_obj_t *l_cache_used_outs = NULL;
     char *l_ledger_cache_group = NULL;
     if (PVT(a_ledger)->cached) {
-        dap_store_obj_t *l_cache_used_outs = DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * (l_outs_used + 1));
+        l_cache_used_outs = DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * (l_outs_used + 1));
         if ( !l_cache_used_outs ) {
             log_it(L_CRITICAL, "%s", g_error_memory_alloc);
             l_ret = -1;
@@ -5168,9 +5169,11 @@ FIN:
         dap_list_free(l_list_tx_out);
     DAP_DEL_Z(l_main_token_ticker);
     if (PVT(a_ledger)->cached) {
-        for (size_t i = 1; i <= l_outs_used; i++) {
-            DAP_DEL_Z(l_cache_used_outs[i].key);
-            DAP_DEL_Z(l_cache_used_outs[i].value);
+        if (l_cache_used_outs) {
+            for (size_t i = 1; i <= l_outs_used; i++) {
+                DAP_DEL_Z(l_cache_used_outs[i].key);
+                DAP_DEL_Z(l_cache_used_outs[i].value);
+            }
         }
         DAP_DEL_Z(l_cache_used_outs);
         DAP_DEL_Z(l_ledger_cache_group);
@@ -5222,7 +5225,7 @@ int dap_ledger_tx_remove(dap_ledger_t *a_ledger, dap_chain_datum_tx_t *a_tx, dap
     dap_store_obj_t *l_cache_used_outs = NULL;
     char *l_ledger_cache_group = NULL;
     if (PVT(a_ledger)->cached) {
-        dap_store_obj_t *l_cache_used_outs = DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * (l_outs_used));
+        l_cache_used_outs = DAP_NEW_Z_SIZE(dap_store_obj_t, sizeof(dap_store_obj_t) * (l_outs_used));
         if ( !l_cache_used_outs ) {
             log_it(L_CRITICAL, "Memory allocation error");
             l_ret = -1;
@@ -5456,9 +5459,11 @@ FIN:
         dap_list_free(l_list_tx_out);
     DAP_DEL_Z(l_main_token_ticker);
     if (PVT(a_ledger)->cached) {
-        for (size_t i = 1; i < l_outs_used; i++) {
-            DAP_DEL_Z(l_cache_used_outs[i].key);
-            DAP_DEL_Z(l_cache_used_outs[i].value);
+        if (l_cache_used_outs) {
+            for (size_t i = 1; i < l_outs_used; i++) {
+                DAP_DEL_Z(l_cache_used_outs[i].key);
+                DAP_DEL_Z(l_cache_used_outs[i].value);
+            }
         }
         DAP_DEL_Z(l_cache_used_outs);
         DAP_DEL_Z(l_ledger_cache_group);
@@ -6325,7 +6330,6 @@ dap_list_t *dap_ledger_get_txs(dap_ledger_t *a_ledger, size_t a_count, size_t a_
     }
     dap_list_t *l_list = NULL;
     size_t l_counter = 0;
-    size_t l_end = l_offset + a_count;
     dap_ledger_tx_item_t *l_item_current, *l_item_tmp;
     HASH_ITER(hh, l_ledger_pvt->ledger_items, l_item_current, l_item_tmp) {
         if (l_counter++ >= l_offset) {
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 0cc600b66a..d0b567fb29 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -588,7 +588,6 @@ json_object *s_net_sync_status(dap_chain_net_t *a_net) {
         l_count_el = 0,
         l_count_el_all = 0,
         l_node_link_nodes = 0;
-    char *l_gdb_nodes = a_net->pub.gdb_nodes;
 
     dap_chain_t *l_chain = NULL;
     DL_FOREACH(a_net->pub.chains, l_chain){
diff --git a/modules/net/dap_chain_net_balancer.c b/modules/net/dap_chain_net_balancer.c
index c0a5e03f68..cbe144ca64 100644
--- a/modules/net/dap_chain_net_balancer.c
+++ b/modules/net/dap_chain_net_balancer.c
@@ -103,8 +103,10 @@ static dap_chain_net_links_t *s_get_ignored_node_addrs(dap_chain_net_t *a_net, s
     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_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));
+    if(l_uplinks)
+        memcpy(l_ret->nodes_info + sizeof(dap_stream_node_addr_t), l_uplinks, l_uplinks_count * sizeof(dap_stream_node_addr_t));
+    if(l_low_availability)
+        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;
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 1c9e8ce9ea..1921127544 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -5544,7 +5544,6 @@ int com_tx_cond_unspent_find(int a_argc, char **a_argv, void **reply)
     }
 
     dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, c_wallets_path);
-    const char* l_sign_str = "";
     if(!l_wallet) {
         dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_TX_COND_UNSPEND_FIND_CAN_NOT_OPEN_WALLET, "Can't open wallet '%s'", l_wallet_str);
         return DAP_CHAIN_NODE_CLI_COM_TX_COND_UNSPEND_FIND_CAN_NOT_OPEN_WALLET;
@@ -5643,6 +5642,7 @@ int com_tx_cond_unspent_find(int a_argc, char **a_argv, void **reply)
     json_object_object_add(l_jobj_total, "datoshi", l_jobj_total_datoshi);
     json_object_object_add(l_jobj_total, "coins", l_jobj_total_coins);
     json_object_object_add(l_jobj_total, "ticker", l_jobj_native_ticker);
+    json_object_object_add(l_jobj_total, "tx_count", json_object_new_uint64(l_tx_count));
     json_object *l_jobj_ret = json_object_new_object();
     json_object_object_add(l_jobj_ret, "transactions_out_cond", l_jobj_tx_list_cond_outs);
     json_object_object_add(l_jobj_ret, "total", l_jobj_total);
@@ -6070,7 +6070,6 @@ int com_tx_create_json(int a_argc, char ** a_argv, void **reply)
     // Read items from json file
     struct json_object *l_json_items = json_object_object_get(l_json, "items");
     size_t l_items_count = json_object_array_length(l_json_items);
-    bool a = (l_items_count = json_object_array_length(l_json_items));
     if(!l_json_items || !json_object_is_type(l_json_items, json_type_array) || !(l_items_count = json_object_array_length(l_json_items))) {
         dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_TX_CREATE_JSON_NOT_FOUNT_ARRAY_ITEMS,
                                "Wrong json format: not found array 'items' or array is empty");
@@ -6448,6 +6447,8 @@ int com_tx_create_json(int a_argc, char ** a_argv, void **reply)
                 log_it(L_WARNING, "Invalid 'in' item, bad prev_hash %s", l_prev_hash_str);
                 char *l_str_err = dap_strdup_printf("Unable to create in for transaction. Invalid 'in' item, "
                                                     "bad prev_hash %s", l_prev_hash_str);
+                json_object *l_jobj_err = json_object_new_string(l_str_err);
+                json_object_array_add(l_jobj_errors, l_jobj_err);
                 // Go to the next item
                 l_list = dap_list_next(l_list);
                 continue;
@@ -6891,6 +6892,7 @@ int com_tx_create(int a_argc, char **a_argv, void **reply)
         return DAP_CHAIN_NODE_CLI_COM_TX_CREATE_WALLET_DOES_NOT_EXIST;
     } else {
         json_object *l_jobj_check_wallet = json_object_new_string(dap_chain_wallet_check_sign(l_wallet));
+        json_object_array_add(*reply, l_jobj_check_wallet);
     }
     const dap_chain_addr_t *addr_from = (const dap_chain_addr_t *) dap_chain_wallet_get_addr(l_wallet, l_net->pub.id);
 
@@ -7447,8 +7449,10 @@ int cmd_gdb_export(int a_argc, char **a_argv, void **a_str_reply)
             size_t l_sign_size = DAP_ENC_BASE64_ENCODE_SIZE(dap_sign_get_size(l_sign))+1;
             char *l_value_enc_str = DAP_NEW_Z_SIZE(char, l_out_size);
             char *l_sign_str = DAP_NEW_Z_SIZE(char, l_sign_size);
-            if(!l_value_enc_str) {
+            if(!l_value_enc_str || !l_sign_str) {
                 log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+                DAP_DEL_Z(l_sign_str);
+                DAP_DEL_Z(l_value_enc_str);
                 return -1;
             }
             dap_enc_base64_encode(l_store_obj[i].value, l_store_obj[i].value_len, l_value_enc_str, DAP_ENC_DATA_TYPE_B64);
@@ -8392,4 +8396,4 @@ void dap_notify_new_client_send_info(dap_events_socket_t *a_es, UNUSED_ARG void
         }
     }
     json_object_put(l_json_wallets);
-}
\ No newline at end of file
+}
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 48365bb435..7eee606d8e 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -711,7 +711,6 @@ static bool s_pay_verificator_callback(dap_ledger_t * a_ledger, dap_chain_tx_out
         log_it(L_ERROR, "Can't get provider sign from receipt.");
         return false;
     }
-    dap_sign_type_t l_provider_sign_type = l_sign->header.type;
 
     if (dap_sign_verify_all(l_sign, dap_sign_get_size(l_sign), &l_receipt->receipt_info, sizeof(l_receipt->receipt_info))){
         log_it(L_ERROR, "Provider sign in receipt not passed verification.");
diff --git a/modules/net/srv/dap_chain_net_srv_order.c b/modules/net/srv/dap_chain_net_srv_order.c
index 62557e7633..32e347d07d 100644
--- a/modules/net/srv/dap_chain_net_srv_order.c
+++ b/modules/net/srv/dap_chain_net_srv_order.c
@@ -549,7 +549,7 @@ int dap_chain_net_srv_order_delete_by_hash_str_sync(dap_chain_net_t *a_net, cons
         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);
 
-        int l_ret = dap_global_db_del_sync(l_gdb_group_str, a_hash_str);
+        l_ret = dap_global_db_del_sync(l_gdb_group_str, a_hash_str);
         DAP_DELETE(l_gdb_group_str);
     }
     return l_ret;
diff --git a/modules/service/datum/dap_chain_net_srv_datum.c b/modules/service/datum/dap_chain_net_srv_datum.c
index 83cb89b1ec..d850434c3e 100644
--- a/modules/service/datum/dap_chain_net_srv_datum.c
+++ b/modules/service/datum/dap_chain_net_srv_datum.c
@@ -204,12 +204,14 @@ void s_order_notficator(dap_store_obj_t *a_obj, void *a_arg)
 {
     if (dap_store_obj_get_type(a_obj) == DAP_GLOBAL_DB_OPTYPE_DEL)
         return;
+    const char * a_obj_key_str = a_obj->key ? a_obj->key : "unknow";
+
     dap_chain_net_t *l_net = (dap_chain_net_t *)a_arg;
     dap_chain_net_srv_order_t *l_order = dap_chain_net_srv_order_read((byte_t *)a_obj->value, a_obj->value_len);    // Old format comliance
-    if (!l_order && a_obj->key) {
-        log_it(L_NOTICE, "Order %s is corrupted", a_obj->key);
+    if (!l_order) {
+        log_it(L_NOTICE, "Order %s is corrupted", a_obj_key_str);
         if (dap_global_db_driver_delete(a_obj, 1) != 0)
-            log_it(L_ERROR,"Can't delete order %s", a_obj->key);
+            log_it(L_ERROR,"Can't delete order %s", a_obj_key_str);
         return; // order is corrupted
     }
 
diff --git a/modules/service/stake/dap_chain_net_srv_stake_lock.c b/modules/service/stake/dap_chain_net_srv_stake_lock.c
index 47f2127497..e1a6969587 100644
--- a/modules/service/stake/dap_chain_net_srv_stake_lock.c
+++ b/modules/service/stake/dap_chain_net_srv_stake_lock.c
@@ -362,7 +362,7 @@ static enum error_code s_cli_hold(int a_argc, char **a_argv, int a_arg_index, da
     }
 
     l_tsd_section = _dap_tsd_get_object(l_tsd, dap_chain_datum_token_tsd_delegate_from_stake_lock_t);
-    if (strcmp(l_ticker_str, (char*)l_tsd_section->ticker_token_from))
+    if (!l_tsd_section || strcmp(l_ticker_str, (char*)l_tsd_section->ticker_token_from))
         return TOKEN_ERROR;
 
     if (IS_ZERO_256(l_tsd_section->emission_rate))
@@ -569,7 +569,7 @@ static enum error_code s_cli_take(int a_argc, char **a_argv, int a_arg_index, da
         }
 
         l_tsd_section = _dap_tsd_get_object(l_tsd, dap_chain_datum_token_tsd_delegate_from_stake_lock_t);
-        if (strcmp(l_ticker_str, (char*)l_tsd_section->ticker_token_from))
+        if (!l_tsd_section || strcmp(l_ticker_str, (char*)l_tsd_section->ticker_token_from))
             return TOKEN_ERROR;
 
         if (!IS_ZERO_256(l_tsd_section->emission_rate)) {
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn.c b/modules/service/vpn/dap_chain_net_srv_vpn.c
index 500e48001f..45b9dca3ec 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -1696,7 +1696,7 @@ static bool s_ch_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
         return false;
 
     dap_chain_net_srv_stream_session_t * l_srv_session = DAP_CHAIN_NET_SRV_STREAM_SESSION (a_ch->stream->session );
-    dap_chain_net_srv_ch_vpn_t *l_ch_vpn = CH_VPN(a_ch);
+    // dap_chain_net_srv_ch_vpn_t *l_ch_vpn = CH_VPN(a_ch);
     dap_chain_net_srv_usage_t * l_usage = l_srv_session->usage_active;// dap_chain_net_srv_usage_find_unsafe(l_srv_session,  l_ch_vpn->usage_id);
 
     if ( ! l_usage){
@@ -1821,7 +1821,7 @@ static bool s_ch_packet_out(dap_stream_ch_t* a_ch, void* a_arg)
 {
     (void) a_arg;
     dap_chain_net_srv_stream_session_t * l_srv_session = DAP_CHAIN_NET_SRV_STREAM_SESSION( a_ch->stream->session );
-    dap_chain_net_srv_ch_vpn_t *l_ch_vpn = CH_VPN(a_ch);
+    // dap_chain_net_srv_ch_vpn_t *l_ch_vpn = CH_VPN(a_ch);
 
     dap_chain_net_srv_usage_t * l_usage = l_srv_session->usage_active;// dap_chain_net_srv_usage_find_unsafe(l_srv_session,  l_ch_vpn->usage_id);
     if ( ! l_usage){
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index 435d68c329..7d026b06d6 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -197,7 +197,7 @@ static int s_callback_client_success(dap_chain_net_srv_t * a_srv, uint32_t a_usa
         dap_stream_ch_pkt_write_unsafe(l_ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
                 pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
         dap_stream_ch_set_ready_to_write_unsafe(l_ch, true);
-        //DAP_DELETE(pkt_out);
+        DAP_DELETE(pkt_out);
     }
 
     // usage is present, we've accepted packets
diff --git a/modules/service/vpn/dap_chain_net_vpn_client_tun.c b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
index 6dd43ef69a..d661daf626 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client_tun.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
@@ -644,7 +644,7 @@ static void ch_sf_pkt_send(dap_stream_ch_t * a_ch, void * a_data, size_t a_data_
     l_pkt_out->header.op_data.data_size = a_data_size;
     memcpy(l_pkt_out->data, a_data, a_data_size);
     dap_stream_ch_pkt_write_unsafe(a_ch, 'd', l_pkt_out, l_pkt_out_size);
-
+    DAP_DELETE(l_pkt_out);
 }
 
 /**
@@ -695,6 +695,7 @@ void ch_sf_tun_client_send(dap_chain_net_srv_ch_vpn_t * ch_sf, void * pkt_data,
         pkt_out->header.sock_id = s_fd_tun;
         dap_stream_ch_pkt_write_unsafe(ch_sf->ch, 'd', pkt_out,
                 pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
+        DAP_DELETE(pkt_out);
     } else {
         //log_it(L_DEBUG, "Raw IP packet daddr:%s saddr:%s  %u from %d bytes sent to tun/tap interface",
         //  str_saddr,str_daddr, sf_pkt->header.op_data.data_size,ret);
diff --git a/modules/service/xchange/dap_chain_net_srv_xchange.c b/modules/service/xchange/dap_chain_net_srv_xchange.c
index dd566ed9bd..17df70e3b5 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -1781,6 +1781,10 @@ static bool s_string_append_tx_cond_info( dap_string_t * a_reply_str,
 
     switch(l_tx_type){
         case TX_TYPE_ORDER:{
+            if (!l_out_cond_item) {
+                log_it(L_ERROR, "Can't find conditional output");
+                return false;
+            }
             char *l_rate_str = dap_chain_balance_to_coins(l_out_cond_item->subtype.srv_xchange.rate);
             const char *l_amount_str, *l_amount_datoshi_str = dap_uint256_to_char(l_out_cond_item->header.value, &l_amount_str);
 
@@ -1803,6 +1807,11 @@ static bool s_string_append_tx_cond_info( dap_string_t * a_reply_str,
             char l_tx_prev_cond_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
             dap_hash_fast_to_str(&l_in_cond->header.tx_prev_hash, l_tx_prev_cond_hash_str, sizeof(l_tx_prev_cond_hash_str));
 
+            if (!l_out_prev_cond_item) {
+                log_it(L_ERROR, "Can't find previous transaction");
+                return false;
+            }
+
             uint256_t l_rate = l_out_cond_item 
                 ? l_out_cond_item->subtype.srv_xchange.rate
                 : l_out_prev_cond_item->subtype.srv_xchange.rate,
@@ -1848,6 +1857,11 @@ static bool s_string_append_tx_cond_info( dap_string_t * a_reply_str,
             char l_tx_prev_cond_hash_str[DAP_CHAIN_HASH_FAST_STR_SIZE];
             dap_hash_fast_to_str(&l_in_cond->header.tx_prev_hash,l_tx_prev_cond_hash_str, sizeof(l_tx_prev_cond_hash_str));
 
+            if (!l_out_prev_cond_item) {
+                log_it(L_ERROR, "Can't find previous transaction");
+                return false;
+            }
+
             dap_chain_datum_tx_t *l_prev_tx = dap_ledger_tx_find_by_hash(a_net->pub.ledger, &l_in_cond->header.tx_prev_hash);
             if (!l_prev_tx)
                 return false;
diff --git a/modules/type/blocks/dap_chain_block_cache.c b/modules/type/blocks/dap_chain_block_cache.c
index 741c37355d..ce599f2b09 100644
--- a/modules/type/blocks/dap_chain_block_cache.c
+++ b/modules/type/blocks/dap_chain_block_cache.c
@@ -67,6 +67,7 @@ dap_chain_block_cache_t *dap_chain_block_cache_new(dap_hash_fast_t *a_block_hash
     l_block_cache->block = a_copy_block ? DAP_DUP_SIZE(a_block, a_block_size) : a_block;
     if (!l_block_cache->block) {
         log_it(L_CRITICAL, "%s", g_error_memory_alloc);
+        DAP_DEL_Z(l_block_cache);
         return NULL;
     }
     l_block_cache->block_size = a_block_size;
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 2e14ab9469..180971b28b 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -401,6 +401,7 @@ static char *s_blocks_decree_set_reward(dap_chain_net_t *a_net, dap_chain_t *a_c
     // Processing will be made according to autoprocess policy
     char *l_ret = dap_chain_mempool_datum_add(l_datum, l_chain_decree, "hex");
     DAP_DELETE(l_datum);
+    DAP_DEL_Z(l_decree);
     return l_ret;
 }
 
@@ -654,7 +655,10 @@ static int s_cli_blocks(int a_argc, char ** a_argv, void **a_str_reply)
                 if (l_err)
                     break;
             }
-            dap_json_rpc_error_add(DAP_CHAIN_NODE_CLI_COM_BLOCK_OK, "All datums processed");
+            json_object* json_obj_out = json_object_new_string("All datums processed");
+            json_object_array_add(*json_arr_reply, json_obj_out);
+            ret = DAP_CHAIN_NODE_CLI_COM_BLOCK_OK;
+            DAP_DEL_Z(l_datums);
             DAP_DELETE(l_gdb_group_mempool);
         } break;
 
@@ -2049,7 +2053,10 @@ static dap_chain_atom_ptr_t s_callback_atom_iter_get(dap_chain_atom_iter_t *a_at
     dap_chain_cs_blocks_t * l_blocks = DAP_CHAIN_CS_BLOCKS(a_atom_iter->chain);
     dap_chain_cs_blocks_pvt_t *l_blocks_pvt = l_blocks ? PVT(l_blocks) : NULL;
     dap_chain_atom_ptr_t l_ret = NULL;
-    assert(l_blocks_pvt);
+    if (!l_blocks_pvt) {
+        log_it(L_ERROR, "l_blocks_pvt is NULL");
+        return NULL;
+    }
     pthread_rwlock_rdlock(&l_blocks_pvt->rwlock);
     switch (a_operation) {
     case DAP_CHAIN_ITER_OP_FIRST:
@@ -2101,7 +2108,7 @@ static void s_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter)
  */
 static dap_chain_atom_ptr_t *s_callback_atom_iter_get_links(dap_chain_atom_iter_t *a_atom_iter , size_t *a_links_size, size_t **a_links_size_ptr)
 {
-    assert(a_atom_iter);
+    dap_return_val_if_fail(a_atom_iter, NULL);
     assert(a_links_size);
     assert(a_links_size_ptr);
     if (!a_atom_iter->cur_item) {
@@ -2118,6 +2125,11 @@ static dap_chain_atom_ptr_t *s_callback_atom_iter_get_links(dap_chain_atom_iter_
         dap_chain_cs_blocks_t *l_cs_blocks = DAP_CHAIN_CS_BLOCKS(a_atom_iter->chain);
         dap_chain_block_cache_t *l_link = dap_chain_block_cache_get_by_hash(l_cs_blocks, &l_block_cache->links_hash[i]);
         assert(l_link);
+        if (!l_link) {
+            DAP_DEL_Z(a_links_size_ptr);
+            DAP_DEL_Z(l_ret);
+            return NULL;
+        }
         (*a_links_size_ptr)[i] = l_link->block_size;
         l_ret[i] = l_link->block;
     }
@@ -2211,7 +2223,7 @@ static size_t s_callback_add_datums(dap_chain_t *a_chain, dap_chain_datum_t **a_
 {
     dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(a_chain);
     dap_chain_cs_blocks_pvt_t *l_blocks_pvt = PVT(l_blocks);
-    dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
+    // dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
 
     size_t l_datum_processed = 0;
     pthread_rwlock_wrlock(&l_blocks_pvt->rwlock);
@@ -2349,8 +2361,15 @@ static uint256_t s_callback_calc_reward(dap_chain_t *a_chain, dap_hash_fast_t *a
     }
     dap_hash_fast_t l_prev_block_hash = l_block_cache->prev_hash;
     HASH_FIND(hh, PVT(l_blocks)->blocks, &l_prev_block_hash, sizeof(l_prev_block_hash), l_block_cache);
-    assert(l_block_cache);
+    if (!l_block_cache) {
+        log_it(L_ERROR, "l_block_cache is NULL");
+        return l_ret;
+    }
     l_block = l_block_cache->block;
+    if (!l_block) {
+        log_it(L_ERROR, "l_block is NULL");
+        return l_ret;
+    }
     assert(l_block);
     dap_time_t l_time_diff = l_block_time - dap_max(l_block->hdr.ts_created, DAP_REWARD_INIT_TIMESTAMP);
     MULT_256_256(l_ret, GET_256_FROM_64(l_time_diff), &l_ret);
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 2f3055ca7d..16fa4911a0 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -1717,7 +1717,7 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
                     dap_string_append_printf(l_str_tmp,"\nEvent %s:\n", l_event_hash_str);
 
                     // Round info
-                    if (l_from_events_str && strcmp(l_from_events_str,"round.new") == 0) {
+                    if ((l_from_events_str && strcmp(l_from_events_str,"round.new") == 0) && l_round_item) {
                         dap_string_append_printf(l_str_tmp,
                             "\tRound info:\n\t\tsigns reject: %d\n",
                             l_round_item->round_info.reject_count);
@@ -1789,7 +1789,7 @@ static int s_cli_dag(int argc, char ** argv, void **a_str_reply)
                                                       l_event_hash_str);
                     ret=-10;
                 }
-                DAP_DELETE(l_round_item);
+                DAP_DEL_Z(l_round_item);
             } break;
 
             case SUBCMD_EVENT_LIST: {
-- 
GitLab