diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index ab5d617d167682665721b6c2fbb9a57f7ab1aed4..7ebd49feb2407d51b08eb5e150f8c0b812520d76 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -2813,7 +2813,7 @@ dap_hash_fast_t *dap_chain_ledger_get_final_chain_tx_hash(dap_ledger_t *a_ledger
         HASH_VALUE(l_tx_hash, sizeof(*l_tx_hash), l_hash_value);
         HASH_FIND_BYHASHVALUE(hh, l_ledger_pvt->ledger_items, l_tx_hash, sizeof(*l_tx_hash), l_hash_value, l_item);
         if (l_item) {
-            int l_out_num = -1;
+            int l_out_num = 0;
             dap_chain_datum_tx_out_cond_get(l_item->tx, a_cond_type, &l_out_num);
             if (l_out_num != -1 && l_out_num < MAX_OUT_ITEMS) {
                 if (dap_hash_fast_is_blank(&l_item->cache_data.tx_hash_spent_fast[l_out_num]))
@@ -2842,12 +2842,11 @@ dap_hash_fast_t *dap_chain_ledger_get_final_chain_tx_hash(dap_ledger_t *a_ledger
 /**
  * Check whether used 'out' items (local function)
  */
-static bool dap_chain_ledger_item_is_used_out(dap_chain_ledger_tx_item_t *a_item, int a_idx_out)
+static dap_hash_fast_t *s_ledger_tx_hash_is_used_out_item(dap_chain_ledger_tx_item_t *a_item, int a_idx_out)
 {
-    bool l_used_out = false;
     if (!a_item || !a_item->cache_data.n_outs) {
         //log_it(L_DEBUG, "list_cached_item is NULL");
-        return true;
+        return NULL;
     }
     if(a_idx_out >= MAX_OUT_ITEMS) {
         if(s_debug_more)
@@ -2856,10 +2855,11 @@ static bool dap_chain_ledger_item_is_used_out(dap_chain_ledger_tx_item_t *a_item
     assert(a_idx_out < MAX_OUT_ITEMS);
     // if there are used 'out' items
     if(a_item->cache_data.n_outs_used > 0) {
-        if(!dap_hash_fast_is_blank(&(a_item->cache_data.tx_hash_spent_fast[a_idx_out])))
-            l_used_out = true;
+        dap_hash_fast_t *l_hash_used = &(a_item->cache_data.tx_hash_spent_fast[a_idx_out]);
+        if(!dap_hash_fast_is_blank(l_hash_used))
+            return l_hash_used;
     }
-    return l_used_out;
+    return NULL;
 }
 
 /**
@@ -3231,7 +3231,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
 
             // 2. Check if out in previous transaction has spent
             int l_idx = (l_cond_type == TX_ITEM_TYPE_IN) ? l_tx_in->header.tx_out_prev_idx : l_tx_in_cond->header.tx_out_prev_idx;
-            if (dap_chain_ledger_item_is_used_out(l_item_out, l_idx)) {
+            if (s_ledger_tx_hash_is_used_out_item(l_item_out, l_idx)) {
                 l_err_num = -6;
                 break;
             }
@@ -3423,7 +3423,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
     if (HASH_COUNT(l_values_from_prev_tx) > 1) {
         l_multichannel = true;
         if (HASH_COUNT(l_values_from_prev_tx) == 2 && !l_main_ticker) {
-            HASH_FIND_STR(l_values_from_cur_tx, PVT(a_ledger)->net_native_ticker, l_value_cur);
+            HASH_FIND_STR(l_values_from_prev_tx, PVT(a_ledger)->net_native_ticker, l_value_cur);
             if (l_value_cur) {
                 l_value_cur = l_value_cur->hh.next ? l_value_cur->hh.next : l_value_cur->hh.prev;
                 l_main_ticker = l_value_cur->token_ticker;
@@ -3483,10 +3483,10 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
         case TX_ITEM_TYPE_OUT_COND: {
             dap_chain_tx_out_cond_t *l_tx_out = (dap_chain_tx_out_cond_t *)l_list_tmp->data;
             if (l_multichannel) {
-                if (l_main_ticker)
-                    l_token = l_main_ticker;
-                else if (l_tx_out->header.subtype == DAP_CHAIN_TX_OUT_COND_SUBTYPE_FEE)
+                if (l_tx_out->header.subtype == DAP_CHAIN_TX_OUT_COND_SUBTYPE_FEE)
                     l_token = (char *)PVT(a_ledger)->net_native_ticker;
+                else if (l_main_ticker)
+                    l_token = l_main_ticker;
                 else {
                     log_it(L_WARNING, "No conditional output support for multichannel transaction");
                     l_err_num = -18;
@@ -4415,12 +4415,12 @@ size_t dap_chain_ledger_count_tps(dap_ledger_t *a_ledger, struct timespec *a_ts_
 /**
  * Check whether used 'out' items
  */
-bool dap_chain_ledger_tx_hash_is_used_out_item(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_tx_hash, int a_idx_out)
+dap_chain_hash_fast_t *dap_chain_ledger_tx_hash_is_used_out_item(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_tx_hash, int a_idx_out)
 {
     dap_chain_ledger_tx_item_t *l_item_out = NULL;
     //dap_chain_datum_tx_t *l_tx =
     s_find_datum_tx_by_hash(a_ledger, a_tx_hash, &l_item_out);
-    return dap_chain_ledger_item_is_used_out(l_item_out, a_idx_out);
+    return s_ledger_tx_hash_is_used_out_item(l_item_out, a_idx_out);
 }
 
 /**
@@ -4499,7 +4499,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
                 {   // if transaction has the out item with requested addr
                     if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
                         // if 'out' item not used & transaction is valid
-                        if(!dap_chain_ledger_item_is_used_out(l_iter_current, l_out_idx_tmp) &&
+                        if(!s_ledger_tx_hash_is_used_out_item(l_iter_current, l_out_idx_tmp) &&
                                 dap_chain_datum_tx_verify_sign(l_cur_tx)) {
                             // uint128_t l_add = dap_chain_uint128_from(l_tx_out->header.value);
                             // balance = dap_uint128_add(balance, l_add);
@@ -4517,7 +4517,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
                 {   // if transaction has the out item with requested addr
                     if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
                         // if 'out' item not used & transaction is valid
-                        if(!dap_chain_ledger_item_is_used_out(l_iter_current, l_out_idx_tmp) &&
+                        if(!s_ledger_tx_hash_is_used_out_item(l_iter_current, l_out_idx_tmp) &&
                                 dap_chain_datum_tx_verify_sign(l_cur_tx)) {
                             SUM_256_256(balance, l_tx_out->header.value, &balance);
                         }
@@ -4532,7 +4532,7 @@ uint256_t dap_chain_ledger_calc_balance_full(dap_ledger_t *a_ledger, const dap_c
                 {   // if transaction has the out item with requested addr
                     if (!memcmp(a_addr, &l_tx_out->addr, sizeof(dap_chain_addr_t))) {
                         // if 'out' item not used & transaction is valid
-                        if(!dap_chain_ledger_item_is_used_out(l_iter_current, l_out_idx_tmp) &&
+                        if(!s_ledger_tx_hash_is_used_out_item(l_iter_current, l_out_idx_tmp) &&
                                 dap_chain_datum_tx_verify_sign(l_cur_tx)) {
                             SUM_256_256(balance, l_tx_out->header.value, &balance);
                         }
diff --git a/modules/chain/include/dap_chain_ledger.h b/modules/chain/include/dap_chain_ledger.h
index 524460b3ad26865b9210bc021bcf4a8e700f1058..8d635165f7f796050fb3bc28fc5de368dbedcfd4 100644
--- a/modules/chain/include/dap_chain_ledger.h
+++ b/modules/chain/include/dap_chain_ledger.h
@@ -202,7 +202,7 @@ void dap_chain_ledger_set_tps_start_time(dap_ledger_t *a_ledger);
 /**
  * Check whether used 'out' items
  */
-bool dap_chain_ledger_tx_hash_is_used_out_item(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_tx_hash, int a_idx_out);
+dap_chain_hash_fast_t *dap_chain_ledger_tx_hash_is_used_out_item(dap_ledger_t *a_ledger, dap_chain_hash_fast_t *a_tx_hash, int a_idx_out);
 
 /**
  * Calculate balance of addr
diff --git a/modules/common/dap_chain_datum.c b/modules/common/dap_chain_datum.c
index 008264644b196b4552cb3808ba887b8d40f89d5f..4ee02f1d7dc563d97bd34299acec03660056b608 100644
--- a/modules/common/dap_chain_datum.c
+++ b/modules/common/dap_chain_datum.c
@@ -732,7 +732,7 @@ void dap_chain_datum_dump(dap_string_t *a_str_out, dap_chain_datum_t *a_datum, c
             dap_string_append_printf(a_str_out, "type: %s\n", l_type_str);
 
             char *l_subtype_str = "";
-            switch(l_decree->header.type)
+            switch(l_decree->header.sub_type)
             {
             case DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_FEE:
                 l_subtype_str = "DECREE_COMMON_SUBTYPE_FEE";
diff --git a/modules/common/dap_chain_datum_decree.c b/modules/common/dap_chain_datum_decree.c
index 1b9a98312faea4390063d86d194b7ceb7593f6e3..edfc1b7612f6da3084610f56e45e0e4ab7b6c520 100644
--- a/modules/common/dap_chain_datum_decree.c
+++ b/modules/common/dap_chain_datum_decree.c
@@ -38,7 +38,7 @@ dap_sign_t *dap_chain_datum_decree_get_signs(dap_chain_datum_decree_t *a_decree,
     if (!a_decree)
         return NULL;
 
-    dap_sign_t *l_signs_section = (dap_sign_t *)((byte_t*)a_decree->data_n_signs + a_decree->header.data_size);
+    dap_sign_t *l_signs_section = (dap_sign_t *)(a_decree->data_n_signs + a_decree->header.data_size);
 
     *a_signs_size = a_decree->header.signs_size;
 
@@ -55,7 +55,7 @@ int dap_chain_datum_decree_get_fee(dap_chain_datum_decree_t *a_decree, uint256_t
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)((byte_t*)a_decree->data_n_signs + l_tsd_offset);
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = l_tsd->size + sizeof(dap_tsd_t);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -84,7 +84,7 @@ int dap_chain_datum_decree_get_fee_addr(dap_chain_datum_decree_t *a_decree, dap_
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)((byte_t*)a_decree->data_n_signs + l_tsd_offset);
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = l_tsd->size + sizeof(dap_tsd_t);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -118,7 +118,7 @@ dap_list_t *dap_chain_datum_decree_get_owners(dap_chain_datum_decree_t *a_decree
 
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)((byte_t*)a_decree->data_n_signs + l_tsd_offset);
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -154,7 +154,7 @@ int dap_chain_datum_decree_get_min_owners(dap_chain_datum_decree_t *a_decree, ui
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -183,7 +183,7 @@ int dap_chain_datum_decree_get_stake_tx_hash(dap_chain_datum_decree_t *a_decree,
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -212,7 +212,7 @@ int dap_chain_datum_decree_get_stake_value(dap_chain_datum_decree_t *a_decree, u
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -241,7 +241,7 @@ int dap_chain_datum_decree_get_stake_signing_addr(dap_chain_datum_decree_t *a_de
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -270,7 +270,7 @@ int dap_chain_datum_decree_get_stake_signer_node_addr(dap_chain_datum_decree_t *
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -299,7 +299,7 @@ int dap_chain_datum_decree_get_stake_min_value(dap_chain_datum_decree_t *a_decre
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
@@ -328,7 +328,7 @@ int dap_chain_datum_decree_get_stake_min_signers_count(dap_chain_datum_decree_t
     size_t l_tsd_offset = 0, tsd_data_size = a_decree->header.data_size;
 
     while(l_tsd_offset < tsd_data_size){
-        dap_tsd_t *l_tsd = (dap_tsd_t*)a_decree->data_n_signs + l_tsd_offset;
+        dap_tsd_t *l_tsd = (dap_tsd_t *)(a_decree->data_n_signs + l_tsd_offset);
         size_t l_tsd_size = dap_tsd_size(l_tsd);
         if(l_tsd_size > tsd_data_size){
             log_it(L_WARNING,"TSD size is greater than all data size. It's possible corrupt data.");
diff --git a/modules/common/dap_chain_datum_tx_items.c b/modules/common/dap_chain_datum_tx_items.c
index 72fd30655ea5f136d93918bff545019d441d19be..4d167c59db3414e4d039e648343e0fc56233178a 100644
--- a/modules/common/dap_chain_datum_tx_items.c
+++ b/modules/common/dap_chain_datum_tx_items.c
@@ -230,7 +230,7 @@ size_t dap_chain_datum_item_tx_get_size(const void *a_item)
  *
  * return item, NULL Error
  */
-dap_chain_tx_in_ems_t *dap_chain_datum_tx_item_token_create(dap_chain_id_t a_id, dap_chain_hash_fast_t *a_datum_token_hash, const char *a_ticker)
+dap_chain_tx_in_ems_t *dap_chain_datum_tx_item_in_ems_create(dap_chain_id_t a_id, dap_chain_hash_fast_t *a_datum_token_hash, const char *a_ticker)
 {
     if(!a_ticker)
         return NULL;
@@ -795,7 +795,7 @@ uint8_t *dap_chain_datum_tx_item_get_nth(dap_chain_datum_tx_t *a_tx, dap_chain_t
 dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a_tx, dap_chain_tx_item_type_t a_cond_type, int *a_out_num)
 {
     dap_list_t *l_list_out_items = dap_chain_datum_tx_items_get(a_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
-    int l_prev_cond_idx = a_out_num ? *a_out_num : -1;
+    int l_prev_cond_idx = a_out_num ? *a_out_num : 0;
     dap_chain_tx_out_cond_t *l_res = NULL;
     for (dap_list_t *l_list_tmp = l_list_out_items; l_list_tmp; l_list_tmp = dap_list_next(l_list_tmp), l_prev_cond_idx++) {
         // Start from *a_out_num + 1 item if a_out_num != NULL
@@ -808,8 +808,11 @@ dap_chain_tx_out_cond_t *dap_chain_datum_tx_out_cond_get(dap_chain_datum_tx_t *a
         }
     }
     dap_list_free(l_list_out_items);
-    if (a_out_num && l_res) {
-        *a_out_num = l_prev_cond_idx;
+    if (a_out_num) {
+        if (l_res)
+            *a_out_num = l_prev_cond_idx;
+        else
+            *a_out_num = -1;
     }
     return l_res;
 }
diff --git a/modules/common/include/dap_chain_datum_tx_items.h b/modules/common/include/dap_chain_datum_tx_items.h
index 0c05bf4054fc19febd882d029cba48c367a5a051..d1747b1450fc6c79f0232829a36c5ce342562017 100644
--- a/modules/common/include/dap_chain_datum_tx_items.h
+++ b/modules/common/include/dap_chain_datum_tx_items.h
@@ -108,7 +108,7 @@ size_t dap_chain_datum_item_tx_get_size(const void *a_item);
  *
  * return item, NULL Error
  */
-dap_chain_tx_in_ems_t *dap_chain_datum_tx_item_token_create(dap_chain_id_t a_id, dap_chain_hash_fast_t *a_datum_token_hash, const char *a_ticker);
+dap_chain_tx_in_ems_t *dap_chain_datum_tx_item_in_ems_create(dap_chain_id_t a_id, dap_chain_hash_fast_t *a_datum_token_hash, const char *a_ticker);
 
 json_object *dap_chain_datum_tx_item_in_ems_to_json(const dap_chain_tx_in_ems_t *a_in_ems);
 
diff --git a/modules/consensus/esbocs/dap_chain_cs_esbocs.c b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
index 01456b2e0b32e2965c642b5702e67a14ba6ff24e..0ce3862729676f69a6010e209020c96ac59b67dd 100644
--- a/modules/consensus/esbocs/dap_chain_cs_esbocs.c
+++ b/modules/consensus/esbocs/dap_chain_cs_esbocs.c
@@ -225,7 +225,7 @@ static int s_callback_created(dap_chain_t *a_chain, dap_config_t *a_chain_net_cf
     dap_chain_esbocs_pvt_t *l_esbocs_pvt = PVT(l_esbocs);
 
     l_esbocs_pvt->minimum_fee = dap_chain_coins_to_balance(dap_config_get_item_str_default(a_chain_net_cfg, "esbocs", "minimum_fee", "0.05"));
-    l_esbocs_pvt->fee_addr = dap_chain_addr_from_str(dap_config_get_item_str_default(a_chain_net_cfg, "esbocs", "fee_addr", NULL));
+    l_esbocs_pvt->fee_addr = dap_chain_addr_from_str(dap_config_get_item_str(a_chain_net_cfg, "esbocs", "fee_addr"));
 
     const char *l_sign_cert_str = NULL;
     if ((l_sign_cert_str = dap_config_get_item_str(a_chain_net_cfg, "esbocs", "blocks-sign-cert")) != NULL) {
@@ -709,7 +709,7 @@ static void s_session_proc_state(dap_chain_esbocs_session_t *a_session)
         if (l_round_skip)
             l_round_timeout += PVT(a_session->esbocs)->round_attempt_timeout * PVT(a_session->esbocs)->round_attempts_max;
         if (a_session->ts_round_sync_start && l_time - a_session->ts_round_sync_start >= l_round_timeout) {
-            if (a_session->cur_round.validators_synced_count * 3 >= dap_list_length(a_session->cur_round.validators_list) * 2) {
+            if (a_session->cur_round.validators_synced_count >= PVT(a_session->esbocs)->min_validators_count) {
                 a_session->cur_round.id = s_session_calc_current_round_id(a_session);
                 debug_if(l_cs_debug, L_MSG, "ESBOCS: net:%s, chain:%s, round:%"DAP_UINT64_FORMAT_U", attempt:%hu."
                                             " Minimum count of validators are synchronized, wait to submit candidate",
@@ -910,7 +910,6 @@ static bool s_session_candidate_to_chain(dap_chain_esbocs_session_t *a_session,
 static void s_session_round_finish(dap_chain_esbocs_session_t *a_session, dap_chain_esbocs_store_t *l_store)
 {
     bool l_cs_debug = PVT(a_session->esbocs)->debug;
-    bool f_compare = false;
     dap_chain_t *l_chain = a_session->chain;
     dap_chain_cs_blocks_t *l_blocks = DAP_CHAIN_CS_BLOCKS(l_chain);
     dap_chain_block_cache_t *l_block_cache = NULL;
@@ -967,15 +966,16 @@ static void s_session_round_finish(dap_chain_esbocs_session_t *a_session, dap_ch
     }
 
     memcpy(&l_precommit_candidate_hash, &l_store->precommit_candidate_hash, sizeof(dap_hash_fast_t));
-    f_compare = dap_hash_fast_compare(&l_store->candidate_hash,&(PVT(a_session->esbocs)->candidate_hash));
-   if(s_session_candidate_to_chain(a_session, &l_store->precommit_candidate_hash, l_store->candidate, l_store->candidate_size)&&f_compare)
-   {
+    bool l_compare = dap_hash_fast_compare(&l_store->candidate_hash,&(PVT(a_session->esbocs)->candidate_hash));
+    if(s_session_candidate_to_chain(a_session, &l_store->precommit_candidate_hash, l_store->candidate, l_store->candidate_size) &&
+            l_compare && PVT(a_session->esbocs)->fee_addr) {
         dap_list_t *l_block_list = NULL;
         l_block_cache = dap_chain_block_cs_cache_get_by_hash(l_blocks, &l_precommit_candidate_hash);
         l_block_list = dap_list_append(l_block_list, l_block_cache);
-        dap_chain_mempool_tx_coll_fee_create(a_session->blocks_sign_key,(PVT(a_session->esbocs)->fee_addr),l_block_list,PVT(a_session->esbocs)->minimum_fee,"hex");
+        dap_chain_mempool_tx_coll_fee_create(a_session->blocks_sign_key, (PVT(a_session->esbocs)->fee_addr),
+                                             l_block_list, PVT(a_session->esbocs)->minimum_fee, "hex");
         dap_list_free(l_block_list);
-   }
+    }
 }
 
 void s_session_sync_queue_add(dap_chain_esbocs_session_t *a_session, dap_chain_esbocs_message_t *a_message, size_t a_message_size)
diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index cac1175df59a577a8ea3b6852fa57b50c0432fc3..728049abe12b2764c2558a3a3e862af640ea54c1 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -612,7 +612,7 @@ char *dap_chain_mempool_tx_create_cond_input(dap_chain_net_t *a_net, dap_chain_h
         return NULL;
     }
     dap_chain_datum_tx_t *l_tx_cond = dap_chain_ledger_tx_find_by_hash(l_ledger, l_tx_final_hash);
-    int l_out_cond_idx;
+    int l_out_cond_idx = 0;
     dap_chain_tx_out_cond_t *l_out_cond = dap_chain_datum_tx_out_cond_get(l_tx_cond, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_PAY, &l_out_cond_idx);
     if (!l_out_cond) {
         log_it(L_WARNING, "Requested conditioned transaction have no conditioned output");
@@ -881,7 +881,7 @@ char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast
         }        
     }
     //in_ems
-    dap_chain_tx_in_ems_t    *l_tx_token = dap_chain_datum_tx_item_token_create(a_emission_chain_id, a_emission_hash, a_ticker);
+    dap_chain_tx_in_ems_t    *l_tx_token = dap_chain_datum_tx_item_in_ems_create(a_emission_chain_id, a_emission_hash, a_ticker);
     if(l_tx_token){
         dap_chain_datum_tx_add_item(&l_tx, (const uint8_t*) l_tx_token);
         DAP_DEL_Z(l_tx_token);
diff --git a/modules/mempool/include/dap_chain_mempool.h b/modules/mempool/include/dap_chain_mempool.h
index db6b5146590868f2ed04a6db6cff1e384fe1e2da..3cf9bc10c56bc92809a4c65a8bd37f8a75877a99 100644
--- a/modules/mempool/include/dap_chain_mempool.h
+++ b/modules/mempool/include/dap_chain_mempool.h
@@ -72,7 +72,8 @@ int dap_chain_mempool_tx_create_massive(dap_chain_t * a_chain, dap_enc_key_t *a_
 
 char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast_t *a_emission_hash,
                                        dap_chain_id_t a_emission_chain_id, uint256_t a_emission_value, const char *a_ticker,
-                                       dap_enc_key_t *a_key_from, dap_chain_addr_t *a_addr_to, dap_cert_t **a_certs, size_t a_certs_count, const char *a_hash_out_type, uint256_t a_value_fee);
+                                       dap_enc_key_t *a_key_from, dap_chain_addr_t *a_addr_to, dap_cert_t **a_certs, size_t a_certs_count,
+                                       const char *a_hash_out_type, uint256_t a_value_fee);
 
 dap_chain_datum_token_emission_t *dap_chain_mempool_emission_get(dap_chain_t *a_chain, const char *a_emission_hash_str);
 dap_chain_datum_token_emission_t *dap_chain_mempool_datum_emission_extract(dap_chain_t *a_chain, byte_t *a_data, size_t a_size);
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index e638d908afe46f782c9797725652cede4cddcf3d..38af819d4c6e44db25edb25ed13dd40aad74baa3 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -5012,11 +5012,11 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
     }
 
     dap_chain_t *l_chain = NULL;
-	if (l_chain_name) {
-		l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_name);
-	} else {
-		l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net,CHAIN_TYPE_TX);
-	}
+    if (l_chain_name) {
+        l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_name);
+    } else {
+        l_chain = dap_chain_net_get_default_chain_by_chain_type(l_net,CHAIN_TYPE_TX);
+    }
 
     if(!l_chain) {
         dap_cli_server_cmd_set_reply_text(a_str_reply, "not found chain name '%s', try use parameter '-chain' or set default datum type in chain configuration file",
diff --git a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
index af330feb011161bde475c3e059a811f554615930..aa27af848ef6176f8240ad7f78639ee3af7af9fb 100644
--- a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
+++ b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
@@ -1505,7 +1505,7 @@ static char *dap_chain_mempool_base_tx_for_stake_lock_create(dap_chain_t *a_chai
     dap_chain_addr_fill_from_key(l_addr_from, a_key_from, l_net->pub.id);
     // create items
 
-    dap_chain_tx_in_ems_t *l_tx_token = dap_chain_datum_tx_item_token_create(a_emission_chain_id, a_emission_hash, a_ticker);
+    dap_chain_tx_in_ems_t *l_tx_token = dap_chain_datum_tx_item_in_ems_create(a_emission_chain_id, a_emission_hash, a_ticker);
 
     dap_chain_tx_in_t *l_in = dap_chain_datum_tx_item_in_create(a_emission_hash, a_tx_out_prev_idx-1);
     //dap_chain_tx_out_t *l_out = dap_chain_datum_tx_item_out_create(a_addr_to, a_emission_value);
diff --git a/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
index 7cf304c000f476c3e1e08b7559e8925ad22fcaa9..b12dd3e6f51530e568eab0ba633b02882607ad42 100644
--- a/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
@@ -75,8 +75,8 @@ int dap_chain_net_srv_stake_pos_delegate_init()
          "\tDelegate public key in specified certificate with specified net name. Pay with specified value of m-tokens of native net token.\n"
     "srv_stake approve -net <net_name> -tx <transaction_hash> -poa_cert <priv_cert_name>\n"
          "\tApprove stake transaction by root node certificate within specified net name\n"
-    "srv_stake transactions -net <net_name> [-cert <delegated_cert>]\n"
-         "\tShow the list of requested, active and canceled stake transactions (optional delegated from addr).\n"
+    "srv_stake keylist -net <net_name> [-cert <delegated_cert>]\n"
+         "\tShow the list of active stake keys (optional delegated with specified cert).\n"
     "srv_stake invalidate -net <net_name> {-tx <transaction_hash> | -cert <delegated_cert> | -cert_pkey_hash <pkey_hash>}"
                             " {-wallet <wallet_name> -fee <value> | -poa_cert <cert_name>}\n"
          "\tInvalidate requested delegated stake transaction by hash or cert name or cert pkey hash within net name and"
@@ -147,13 +147,20 @@ void dap_chain_net_srv_stake_key_delegate(dap_chain_net_t *a_net, dap_chain_addr
     assert(s_srv_stake);
     if (!a_signing_addr || !a_node_addr || !a_stake_tx_hash)
         return;
-    dap_chain_net_srv_stake_item_t *l_stake = DAP_NEW_Z(dap_chain_net_srv_stake_item_t);
+    dap_chain_net_srv_stake_item_t *l_stake = NULL;
+    bool l_found = false;
+    HASH_FIND(hh, s_srv_stake->itemlist, a_signing_addr, sizeof(dap_chain_addr_t), l_stake);
+    if (!l_stake)
+        l_stake = DAP_NEW_Z(dap_chain_net_srv_stake_item_t);
+    else
+        l_found = true;
     l_stake->net = a_net;
     l_stake->node_addr = *a_node_addr;
     l_stake->signing_addr = *a_signing_addr;
     l_stake->value = a_value;
     l_stake->tx_hash = *a_stake_tx_hash;
-    HASH_ADD(hh, s_srv_stake->itemlist, signing_addr, sizeof(dap_chain_addr_t), l_stake);
+    if (!l_found)
+        HASH_ADD(hh, s_srv_stake->itemlist, signing_addr, sizeof(dap_chain_addr_t), l_stake);
 
 }
 
@@ -454,7 +461,14 @@ static dap_chain_datum_decree_t *s_stake_decree_approve(dap_chain_net_t *a_net,
     l_decree->header.ts_created = dap_time_now();
     l_decree->header.type = DAP_CHAIN_DATUM_DECREE_TYPE_COMMON;
     l_decree->header.common_decree_params.net_id = a_net->pub.id;
-    l_decree->header.common_decree_params.chain_id = dap_chain_net_get_default_chain_by_chain_type(a_net, CHAIN_TYPE_DECREE)->id;
+    dap_chain_t *l_chain = dap_chain_net_get_default_chain_by_chain_type(a_net, CHAIN_TYPE_DECREE);
+    if (!l_chain)
+        l_chain =  dap_chain_net_get_chain_by_chain_type(a_net, CHAIN_TYPE_DECREE);
+    if (!l_chain) {
+        log_it(L_ERROR, "No chain supported decree datum type");
+        return NULL;
+    }
+    l_decree->header.common_decree_params.chain_id = l_chain->id;
     l_decree->header.common_decree_params.cell_id = *dap_chain_net_get_cur_cell(a_net);
     l_decree->header.sub_type = DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_STAKE_APPROVE;
     l_decree->header.data_size = l_total_tsd_size;
@@ -1014,7 +1028,7 @@ static void s_srv_stake_print(dap_chain_net_srv_stake_item_t *a_stake, dap_strin
 static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
 {
     enum {
-        CMD_NONE, CMD_ORDER, CMD_DELEGATE, CMD_APPROVE, CMD_TX_LIST, CMD_INVALIDATE, CMD_MIN_VALUE
+        CMD_NONE, CMD_ORDER, CMD_DELEGATE, CMD_APPROVE, CMD_KEY_LIST, CMD_INVALIDATE, CMD_MIN_VALUE
     };
     int l_arg_index = 1;
 
@@ -1039,8 +1053,8 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
         l_cmd_num = CMD_APPROVE;
     }
     // Show the tx list with frozen staker funds
-    else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "transactions", NULL)) {
-        l_cmd_num = CMD_TX_LIST;
+    else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "keylist", NULL)) {
+        l_cmd_num = CMD_KEY_LIST;
     }
     // Return staker's funds
     else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "invalidate", NULL)) {
@@ -1201,7 +1215,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
             DAP_DELETE(l_decree);
             dap_cli_server_cmd_set_reply_text(a_str_reply, "Approve decree successfully created");
         } break;
-        case CMD_TX_LIST: {
+        case CMD_KEY_LIST: {
             const char *l_net_str = NULL,
                        *l_cert_str = NULL;
             l_arg_index++;
diff --git a/modules/service/xchange/dap_chain_net_srv_xchange.c b/modules/service/xchange/dap_chain_net_srv_xchange.c
index 985e569f084505942f535bf806a0c510f0ba2ffc..0b385b33613fd031ce2192f162c0a9da07f11acc 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -775,7 +775,7 @@ static bool s_xchange_tx_invalidate(dap_chain_net_srv_xchange_price_t *a_price,
     }
     const char *l_tx_ticker = dap_chain_ledger_tx_get_token_ticker_by_hash(l_ledger, &a_price->tx_hash);
     bool l_single_channel = !dap_strcmp(l_tx_ticker, l_native_ticker);
-    int l_prev_cond_idx;
+    int l_prev_cond_idx = 0;
     dap_chain_tx_out_cond_t *l_tx_out_cond = dap_chain_datum_tx_out_cond_get(l_cond_tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_SRV_XCHANGE,
                                                                              &l_prev_cond_idx);
     if (dap_chain_ledger_tx_hash_is_used_out_item(l_ledger, &a_price->tx_hash, l_prev_cond_idx)) {
@@ -1542,7 +1542,8 @@ char l_hash_str [DAP_CHAIN_HASH_FAST_STR_SIZE + 8] = {0};
 dap_chain_hash_fast_t l_tx_first_hash = {0};
 dap_chain_datum_tx_t    *l_datum_tx;
 size_t  l_datum_tx_size, l_tx_total, l_tx_count;
-int l_item_idx, l_rc;
+int l_item_idx;
+dap_hash_fast_t *l_rc;
 dap_string_t *l_reply_str;
 dap_hash_fast_t l_hash;
 dap_chain_tx_out_cond_t *l_out_cond_item;
@@ -1633,7 +1634,8 @@ dap_chain_tx_out_cond_t *l_out_cond_item;
 static int s_cli_srv_xchange(int a_argc, char **a_argv, char **a_str_reply)
 {
     enum {CMD_NONE = 0, CMD_ORDER, CMD_ORDERS, CMD_PURCHASE, CMD_ENABLE, CMD_DISABLE, CMD_TX_LIST, CMD_TOKEN_PAIR };
-    int l_arg_index = 1, l_cmd_num = CMD_NONE, l_rc;
+    int l_arg_index = 1, l_cmd_num = CMD_NONE;
+    dap_hash_fast_t *l_rc;
 
     if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "order", NULL)) {
         l_cmd_num = CMD_ORDER;