diff --git a/modules/chain/dap_chain_cs.c b/modules/chain/dap_chain_cs.c
index cb7b88a782796c432b5a172ce1cf204faed15843..5d5420556ffaac66494005f36fe2f3fde934f0cc 100644
--- a/modules/chain/dap_chain_cs.c
+++ b/modules/chain/dap_chain_cs.c
@@ -121,8 +121,12 @@ void dap_chain_cs_add (const char * a_cs_str,  dap_chain_callback_new_cfg_t a_ca
 int dap_chain_cs_create(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
 {
     dap_chain_callback_new_cfg_item_t *l_item = NULL;
-#ifdef DAP_CHAIN_BLOCKS_TEST
-    const char *l_consensus = dap_strdup("esbocs");
+#if defined(DAP_CHAIN_BLOCKS_TEST) || defined(DAP_LEDGER_TEST)
+    const char *l_consensus = NULL;
+    if (a_chain->id.uint64 == 0)
+        l_consensus = dap_strdup("dag_poa");
+    else
+        l_consensus = dap_strdup("esbocs");
 #else
     const char *l_consensus = dap_config_get_item_str( a_chain_cfg, "chain", "consensus");
 #endif
diff --git a/modules/chain/tests/CMakeLists.txt b/modules/chain/tests/CMakeLists.txt
index 667b10be69fd8001e041c52dbd82dff01e8b8fb7..69f2e3f0ffe89e13cbed7675364773a4e26b717f 100755
--- a/modules/chain/tests/CMakeLists.txt
+++ b/modules/chain/tests/CMakeLists.txt
@@ -7,7 +7,7 @@ file(GLOB DAP_CHAIN_TESTS_SRC *.c)
 
 add_executable(${PROJECT_NAME} ${DAP_CHAIN_TESTS_SRC} ${DAP_CHAIN_TESTS_HEADERS})
 
-target_link_libraries(${PROJECT_NAME} dap_test dap_core dap_chain dap_chain_wallet dap_chain_net_srv_vpn)
+target_link_libraries(${PROJECT_NAME} dap_test dap_core dap_chain dap_chain_wallet dap_chain_net_srv_vpn dap_chain_cs_blocks dap_chain_cs_dag_poa)
 
 if (DARWIN)
     target_link_libraries(${PROJECT_NAME} bz2)
diff --git a/modules/chain/tests/dap_chain_ledger_tests.c b/modules/chain/tests/dap_chain_ledger_tests.c
index 08450793811c148ee058100e0e03e3a25e553369..7c4f9d57c463a6a9f07bf330807c287d7c506e7f 100644
--- a/modules/chain/tests/dap_chain_ledger_tests.c
+++ b/modules/chain/tests/dap_chain_ledger_tests.c
@@ -5,11 +5,18 @@
 #include "dap_chain_wallet.h"
 #include "dap_math_ops.h"
 #include "dap_config.h"
+#include "dap_chain.h"
 #include "dap_chain_net.h"
 #include "dap_chain_common.h"
 #include "dap_chain_net_srv_vpn.h"
 #include "dap_chain_net_srv_stake_lock.h"
 #include "dap_chain_net_srv_stake_pos_delegate.h"
+#include "dap_chain_net_decree.h"
+#include "dap_chain_block.h"
+#include "dap_chain_cs_blocks.h"
+#include "dap_chain_cs_esbocs.h"
+#include "dap_chain_cs.h"
+#include "dap_chain_cs_dag_poa.h"
 
 static const uint64_t s_fee = 2;
 static const uint64_t s_total_supply = 500;
@@ -297,6 +304,115 @@ dap_chain_datum_tx_t *dap_ledger_test_create_unstake_tx_cond(dap_enc_key_t *a_ke
     return l_tx;
 }
 
+
+int dap_ledger_test_create_reward_decree(dap_chain_t *a_chain, dap_chain_net_id_t a_net_id, uint256_t a_value, dap_cert_t *a_cert)
+{
+    // Create decree
+    size_t l_tsd_total_size = sizeof(dap_tsd_t) + sizeof(uint256_t);
+    size_t l_decree_size = sizeof(dap_chain_datum_decree_t) + l_tsd_total_size;
+    dap_chain_datum_decree_t *l_decree = DAP_NEW_Z_SIZE(dap_chain_datum_decree_t, l_decree_size);
+    if (!l_decree) {
+        return -1;
+    }
+    // Fill the header
+    l_decree->decree_version = DAP_CHAIN_DATUM_DECREE_VERSION;
+    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_id;
+    l_decree->header.common_decree_params.chain_id = a_chain->id;
+    l_decree->header.common_decree_params.cell_id = (dap_chain_cell_id_t){.uint64 = 0};
+    l_decree->header.sub_type = DAP_CHAIN_DATUM_DECREE_COMMON_SUBTYPE_REWARD;
+    l_decree->header.data_size = l_tsd_total_size;
+    // Fill a TSD section
+    dap_tsd_t *l_tsd = (dap_tsd_t *)l_decree->data_n_signs;
+    l_tsd->type = DAP_CHAIN_DATUM_DECREE_TSD_TYPE_VALUE;
+    l_tsd->size = sizeof(uint256_t);
+    *(uint256_t*)(l_tsd->data) = a_value;
+    // Sign it
+    dap_sign_t *l_sign = dap_cert_sign(a_cert, l_decree, l_decree_size, 0);
+    if (!l_sign) {
+        DAP_DELETE(l_decree);
+        return -2;
+    }
+    size_t l_sign_size = dap_sign_get_size(l_sign);
+    l_decree_size += l_sign_size;
+    l_decree->header.signs_size = l_sign_size;
+    void *l_decree_rl = DAP_REALLOC(l_decree, l_decree_size);
+    if (!l_decree_rl) {
+        DAP_DELETE(l_decree);
+        return -3;
+    } else
+        l_decree = l_decree_rl;
+    memcpy(l_decree->data_n_signs + l_tsd_total_size, l_sign, l_sign_size);
+    DAP_DELETE(l_sign);
+
+    // dap_chain_datum_t *l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_DECREE, l_decree, l_decree_size);
+
+    dap_hash_fast_t l_decree_hash = {};
+    dap_hash_fast(l_decree, l_decree_size, &l_decree_hash);
+    // a_chain->callback_atom_add();
+    dap_assert_PIF(dap_chain_net_decree_apply(&l_decree_hash, l_decree, a_chain)==0, "Decree applying:");
+    return 0;
+}
+
+int dap_ledger_test_create_reward_tx(dap_chain_t *a_chain, dap_enc_key_t *a_key_to, int block_num, dap_hash_fast_t a_block_hash, uint256_t a_value, dap_ledger_t *a_ledger)
+{
+
+    dap_chain_t *l_chain = a_chain;
+    //add tx
+    dap_chain_datum_tx_t *l_tx = dap_chain_datum_tx_create();
+    dap_pkey_t *l_sign_pkey = dap_pkey_from_enc_key(a_key_to);
+    dap_hash_fast_t l_sign_pkey_hash;
+    dap_pkey_get_hash(l_sign_pkey, &l_sign_pkey_hash);
+    uint256_t l_value_out = uint256_0;
+    dap_ledger_t *l_ledger = a_ledger;
+
+    uint256_t l_reward_value = l_chain->callback_calc_reward(l_chain, a_block_hash, l_sign_pkey);
+    dap_assert_PIF(!IS_ZERO_256(l_reward_value), "Reward calculating:");
+    dap_assert_PIF(dap_ledger_is_used_reward(l_ledger, a_block_hash, &l_sign_pkey_hash), "Reward is collected. ");
+    //add 'in_reward' items
+    dap_chain_datum_tx_add_in_reward_item(&l_tx, a_block_hash);
+    SUM_256_256(l_value_out, l_reward_value, &l_value_out);
+
+    DAP_DELETE(l_sign_pkey);
+    uint256_t l_net_fee = uint256_0, l_total_fee = uint256_0;
+    dap_chain_addr_t l_addr_fee = c_dap_chain_addr_blank;
+ 
+    // Check and apply sovereign tax for this key
+    uint256_t l_value_tax = {};
+    dap_chain_net_srv_stake_item_t *l_key_item = dap_chain_net_srv_stake_check_pkey_hash(l_chain->net_id, &l_sign_pkey_hash);
+    if (l_key_item && !IS_ZERO_256(l_key_item->sovereign_tax) &&
+                !dap_chain_addr_is_blank(&l_key_item->sovereign_addr)) {
+        MULT_256_COIN(l_value_out, l_key_item->sovereign_tax, &l_value_tax);
+        if (compare256(l_value_tax, l_value_out) < 1)
+            SUBTRACT_256_256(l_value_out, l_value_tax, &l_value_out);
+    }
+    //add 'out' items
+    if (!IS_ZERO_256(l_value_out)) {
+        if (dap_chain_datum_tx_add_out_item(&l_tx, a_addr_to, l_value_out) != 1) {
+            dap_chain_datum_tx_delete(l_tx);
+            log_it(L_WARNING, "Can't create out item in transaction fee");
+            return NULL;
+        }
+    }
+    if (!IS_ZERO_256(l_value_tax)) {
+        if (dap_chain_datum_tx_add_out_item(&l_tx, &l_key_item->sovereign_addr, l_value_tax) != 1) {
+            dap_chain_datum_tx_delete(l_tx);
+            log_it(L_WARNING, "Can't create out item in transaction fee");
+            return NULL;
+        }
+    }
+    // add 'sign' item
+    if(dap_chain_datum_tx_add_sign_item(&l_tx, a_sign_key) != 1) {
+        dap_chain_datum_tx_delete(l_tx);
+        log_it(L_WARNING, "Can't sign item in transaction fee");
+        return NULL;
+    }
+
+    return 0;
+}
+
+
 /* dap_chain_datum_tx_t *dap_ledger_test_create_delegate_tx_cond(dap_enc_key_t *a_key_from, dap_chain_hash_fast_t *a_hash_prev, uint256_t a_value, dap_ledger_t *a_ledger) {
     dap_chain_net_srv_uid_t l_uid = { .uint64 = DAP_CHAIN_NET_SRV_STAKE_LOCK_ID };
     // get previous transaction
@@ -496,30 +612,52 @@ void dap_ledger_test_datums_removing(dap_ledger_t *a_ledger, dap_hash_fast_t *a_
     sleep(3);
     // Create stake unlock tx
     uint256_t l_balance_before_unstaking = dap_ledger_test_print_balance(a_ledger, &l_addr);
+    uint256_t l_balance_delegated_before_unstaking = dap_ledger_test_print_delegate_balance(a_ledger, &l_addr);
+    dap_assert(!compare256(l_balance_delegated_before_unstaking, dap_chain_uint256_from(2U)), "Compare delegated token balance before creating unstake transactions:")
+    
     dap_chain_datum_tx_t *l_unstake_cond_tx = dap_ledger_test_create_unstake_tx_cond(a_from_key, &l_stake_cond_tx_hash, dap_chain_uint256_from(20U), a_ledger);
     dap_hash_fast_t l_unstake_cond_tx_hash = {};
     dap_hash_fast(l_unstake_cond_tx, dap_chain_datum_tx_get_size(l_stake_cond_tx), &l_unstake_cond_tx_hash);
     err_code = dap_ledger_tx_add(a_ledger, l_unstake_cond_tx, &l_unstake_cond_tx_hash, false);
     printf("err_code = %s\n", dap_ledger_tx_check_err_str(err_code));
     dap_assert(!err_code, "Adding of unstake cond transaction to ledger is");
+    uint256_t l_balance_delegated_after_unstaking = dap_ledger_test_print_delegate_balance(a_ledger, &l_addr);
+    dap_assert(!compare256(l_balance_delegated_after_unstaking, uint256_0), "Compare delegated token balance after creating unstake transactions:")
     
     err_code = dap_ledger_tx_remove(a_ledger, l_unstake_cond_tx, &l_unstake_cond_tx_hash);
     printf("err_code = %s\n", dap_ledger_tx_check_err_str(err_code));
     dap_assert(!err_code, "Test of unstake conditional transaction removing from ledger:");
     l_balance_after = dap_ledger_test_print_balance(a_ledger, &l_addr);
+    dap_assert(!compare256(l_balance_delegated_after_unstaking, uint256_0), "Compare delegated token balance after removing unstake transaction:")
+    uint256_t l_balance_delegated_after_removing_unstaking = dap_ledger_test_print_delegate_balance(a_ledger, &l_addr);
     dap_assert(!compare256(l_balance_before_unstaking, l_balance_after), "Compare balance after creating unstake transactions and after removing them. Must be equal:")
     }
 
     // Check delegation
+    {
     
+    }
 
-    // CHeck rewards
+    // Check rewards
+    {
+
+    }
 
     // Check vote removing 
+    {
+
+    }
 
     // Check voting removing
+    {
+
+    }
 
     // Check exchanger
+    {
+
+    }
+
 
 }
 
@@ -801,24 +939,41 @@ void dap_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a_cert,
 
 void dap_ledger_test_run(void){
     dap_set_appname("cellframe-node");
-    // dap_config_init("/opt/cellframe-node/etc");
-    // dap_assert_PIF((g_config = dap_config_open(dap_get_appname())) != NULL, "Init: ");
+    dap_assert_PIF(dap_chain_cs_blocks_init() == 0, "Initialization of dap consensus block: ");
+    dap_assert_PIF(dap_chain_cs_esbocs_init() == 0, "Initialization of esbocs: ");
+    dap_assert_PIF(dap_chain_cs_dag_init() == 0, "Initialization of esbocs: ");
+    dap_assert_PIF(dap_chain_cs_dag_poa_init() == 0, "Initialization of esbocs: ");
     dap_chain_net_srv_stake_lock_init();
     dap_chain_net_srv_stake_pos_delegate_init();
     dap_assert_PIF(!dap_chain_net_srv_init(), "Srv initializstion");
-    dap_chain_net_id_t l_iddn = {0};
-    sscanf("0xFA0", "0x%16"DAP_UINT64_FORMAT_x, &l_iddn.uint64);
+    
     dap_print_module_name("dap_ledger");
     uint16_t l_flags = 0;
     l_flags |= DAP_LEDGER_CHECK_TOKEN_EMISSION;
-    dap_chain_net_t *l_net = DAP_NEW_Z(dap_chain_net_t);
-    l_net->pub.id = l_iddn;
-    l_net->pub.native_ticker = s_token_ticker;
-    l_net->pub.name = "Snet";
+    dap_chain_net_test_init();
+    dap_chain_net_id_t l_iddn = {.uint64 = 0};
+    sscanf("0xFA0", "0x%16"DAP_UINT64_FORMAT_x, &l_iddn.uint64);
+    dap_chain_net_t *l_net = dap_chain_net_by_id(l_iddn);
     dap_ledger_t *l_ledger = dap_ledger_create(l_net, l_flags);
+
+    dap_chain_t *l_chain_zero =  dap_chain_create(l_net->pub.name, "test_chain_zerochain", l_net->pub.id, (dap_chain_id_t){.uint64 = 0});
+    dap_config_t l_cfg = {};
+    dap_assert_PIF(dap_chain_cs_create(l_chain_zero, &l_cfg) == 0, "Chain cs dag_poa creating: ");
+    DL_APPEND(l_net->pub.chains, l_chain_zero);
+
+    dap_chain_t *l_chain_main =  dap_chain_create(l_net->pub.name, "test_chain_main", l_net->pub.id, (dap_chain_id_t){.uint64 = 1});
+    dap_assert_PIF(dap_chain_cs_create(l_chain_main, &l_cfg) == 0, "Chain esbocs cs creating: ");
+    DL_APPEND(l_net->pub.chains, l_chain_main);
+
+    dap_assert_PIF(!dap_chain_net_decree_init(l_net), "Decree initialization:");
+
     char *l_seed_ph = "H58i9GJKbn91238937^#$t6cjdf";
     size_t l_seed_ph_size = strlen(l_seed_ph);
     dap_cert_t *l_cert = dap_cert_generate_mem_with_seed("testCert", DAP_ENC_KEY_TYPE_SIG_PICNIC, l_seed_ph, l_seed_ph_size);
+
+    dap_assert_PIF(dap_ledger_test_create_reward_decree(l_chain_main, l_net->pub.id,  dap_chain_uint256_from(2), l_cert)==0, "Reward decree creating:");
+
+
     size_t l_token_decl_size = 0;
     dap_chain_datum_token_t *l_token_decl = dap_ledger_test_create_datum_decl(l_cert,
                                                                                     &l_token_decl_size, s_token_ticker,
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index 2aaac68b091d488e62da30ecdb513f22b6efe50a..d14ada793a2f29986780a9e4fc45d8fa9ca8f2dc 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -363,6 +363,7 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
     dap_chain_cs_dag_poa_pvt_t *l_poa_pvt = PVT(l_poa);
     pthread_rwlock_init(&l_poa_pvt->rounds_rwlock, NULL);
     // PoA rounds
+#ifndef DAP_LEDGER_TEST
     l_poa_pvt->confirmations_timeout = dap_config_get_item_uint32_default(a_chain_cfg,"dag-poa","confirmations_timeout",600);
     l_poa_pvt->auto_confirmation = dap_config_get_item_bool_default(a_chain_cfg,"dag-poa","auto_confirmation",true);
     l_poa_pvt->auto_round_complete = dap_config_get_item_bool_default(a_chain_cfg,"dag-poa","auto_round_complete",true);
@@ -406,6 +407,15 @@ static int s_callback_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
         }
     }
 
+#else
+    l_poa_pvt->auth_certs_count = 1;
+    l_poa_pvt->auth_certs = DAP_NEW_Z_SIZE ( dap_cert_t *, l_poa_pvt->auth_certs_count * sizeof(dap_cert_t *));
+    char *l_seed_ph = "H58i9GJKbn91238937^#$t6cjdf";
+    size_t l_seed_ph_size = strlen(l_seed_ph);
+    dap_cert_t *l_cert = dap_cert_generate_mem_with_seed("testCert", DAP_ENC_KEY_TYPE_SIG_PICNIC, l_seed_ph, l_seed_ph_size);
+    l_poa_pvt->auth_certs[0] = l_cert;
+#endif
+
     return 0;
 }
 
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index f9e95d943c2b584aeab478039c91084ec14d47ce..3a199a50c6624fb09ef9ad42fc2f76ca594bfe78 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -1789,6 +1789,30 @@ void dap_chain_net_delete(dap_chain_net_t *a_net)
     DAP_DELETE(a_net);
 }
 
+#ifdef DAP_LEDGER_TEST
+int dap_chain_net_test_init()
+{
+    dap_chain_net_id_t l_iddn = {0};
+    sscanf("0xFA0", "0x%16"DAP_UINT64_FORMAT_x, &l_iddn.uint64);
+    dap_chain_net_t *l_net = s_net_new(&l_iddn, "Snet", "TestCoin", "root");
+    
+    
+    // l_net->pub.id.uint64 = l_iddn.uint64;
+    // l_net->pub.native_ticker = "TestCoin";
+    // l_net->pub.name = "Snet";
+
+    dap_chain_net_item_t *l_net_item = DAP_NEW_Z(dap_chain_net_item_t);
+    dap_strncpy(l_net_item->name, "Snet", DAP_CHAIN_NET_NAME_MAX);
+    l_net_item->chain_net = l_net;
+    l_net_item->net_id.uint64 = l_net->pub.id.uint64;
+
+    HASH_ADD(hh2, s_net_ids, net_id, sizeof(l_net_item->net_id), l_net_item);
+
+    return 0;
+}
+#endif
+
+
 /**
  * @brief load network config settings from cellframe-node.cfg file
  *
@@ -2078,7 +2102,6 @@ int s_net_init(const char *a_net_name, uint16_t a_acl_idx)
     dap_chain_net_decree_init(l_net);
 
     l_net->pub.config = l_cfg;
-
     return 0;
 }
 
diff --git a/modules/net/dap_chain_net_decree.c b/modules/net/dap_chain_net_decree.c
index b805446d2a36bf5296659e9ebdb1001a7a30f65c..93249b7e8972326c975acf014bff2753e7d15086 100644
--- a/modules/net/dap_chain_net_decree.c
+++ b/modules/net/dap_chain_net_decree.c
@@ -240,7 +240,7 @@ int dap_chain_net_decree_apply(dap_hash_fast_t *a_decree_hash, dap_chain_datum_d
 
     l_net = dap_chain_net_by_id(a_chain->net_id);
 
-    if (!l_net->pub.decree)
+    if (!l_net || !l_net->pub.decree)
     {
         log_it(L_WARNING,"Decree is not inited!");
         return -108;
diff --git a/modules/net/include/dap_chain_net.h b/modules/net/include/dap_chain_net.h
index ef73031a2d480d83d59cfedcbe5fe408c0b3e981..e98b723bd74d11e90d4d6e61d30046c14c02fb25 100644
--- a/modules/net/include/dap_chain_net.h
+++ b/modules/net/include/dap_chain_net.h
@@ -91,6 +91,9 @@ typedef bool (dap_chain_datum_filter_func_t)(dap_chain_datum_t *a_datum, dap_cha
 
 int dap_chain_net_init(void);
 void dap_chain_net_deinit(void);
+#ifdef DAP_LEDGER_TEST
+int dap_chain_net_test_init();
+#endif
 
 DAP_STATIC_INLINE uint64_t dap_chain_net_get_cur_addr_int(dap_chain_net_t *a_net) { return g_node_addr.uint64; }
 
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 7b87103bd1fb1b01571cf7a348893d972fe9b8d2..4a89ebb9c50c93bbdb520eaa448c9b401cd5ff3f 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -100,7 +100,7 @@ static dap_chain_atom_ptr_t s_chain_callback_atom_add_from_treshold(dap_chain_t
 static dap_chain_atom_verify_res_t s_chain_callback_atom_verify(dap_chain_t * a_chain, dap_chain_atom_ptr_t , size_t, dap_hash_fast_t *a_atom_hash);                   //    Verify new event in dag
 static size_t s_chain_callback_atom_get_static_hdr_size(void);                               //    Get dag event header size
 
-static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from, bool a_show_forked_branches);
+static dap_chain_atom_iter_t* s_chain_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from);
 
 static dap_chain_atom_ptr_t s_chain_callback_atom_iter_find_by_hash(dap_chain_atom_iter_t * a_atom_iter ,
                                                                        dap_chain_hash_fast_t * a_atom_hash, size_t * a_atom_size);
@@ -277,9 +277,13 @@ static int s_chain_cs_dag_new(dap_chain_t * a_chain, dap_config_t * a_chain_cfg)
     l_dag->is_add_directly = dap_config_get_item_bool_default(a_chain_cfg,"dag","is_add_directly",false);
     l_dag->datum_add_hashes_count = dap_config_get_item_uint16_default(a_chain_cfg,"dag","datum_add_hashes_count",1);
     dap_chain_net_t *l_net = dap_chain_net_by_id(a_chain->net_id);
+#ifndef DAP_LEDGER_TEST
     l_dag->gdb_group_events_round_new = dap_strdup_printf(l_dag->is_celled ? "dag-%s-%s-%016llx-round.new" : "dag-%s-%s-round.new",
                                           l_net->pub.gdb_groups_prefix, a_chain->name, 0LLU);
-
+#else
+    l_dag->gdb_group_events_round_new = dap_strdup_printf(l_dag->is_celled ? "dag-%s-%s-%016llx-round.new" : "dag-%s-%s-round.new",
+                                        "Snet", a_chain->name, 0LLU);
+#endif
     PVT(l_dag)->treshold_fee_timer = dap_interval_timer_create(900000, (dap_timer_callback_t)s_dap_chain_cs_dag_threshold_free, l_dag);
 
     log_it (L_NOTICE, "DAG chain initialized (%s)", l_dag->is_single_line ? "single line" : "multichain");
@@ -1073,7 +1077,7 @@ static dap_chain_atom_ptr_t* s_chain_callback_atom_iter_get_links( dap_chain_ato
  * @param a_chain
  * @return
  */
-static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from, bool a_show_forked_branches)
+static dap_chain_atom_iter_t *s_chain_callback_atom_iter_create(dap_chain_t *a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from)
 {
     dap_chain_atom_iter_t * l_atom_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
     if (!l_atom_iter) {
diff --git a/modules/type/none/dap_chain_cs_none.c b/modules/type/none/dap_chain_cs_none.c
index 6346fb5472af8fe61d3671a9f7918442342a11f9..0b74412da95e98a4642e4c334b30752185f9d4f8 100644
--- a/modules/type/none/dap_chain_cs_none.c
+++ b/modules/type/none/dap_chain_cs_none.c
@@ -64,7 +64,7 @@ static dap_chain_atom_verify_res_t s_nonconsensus_callback_atom_add(dap_chain_t
 static dap_chain_atom_verify_res_t s_nonconsensus_callback_atom_verify(dap_chain_t * a_chain, dap_chain_atom_ptr_t, size_t, dap_hash_fast_t *a_atom_hash); //    Verify new event in gdb
 static size_t s_nonconsensus_callback_atom_get_static_hdr_size(void); //    Get gdb event header size
 
-static dap_chain_atom_iter_t* s_nonconsensus_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from, bool a_show_forked_branches);
+static dap_chain_atom_iter_t* s_nonconsensus_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from);
 
 // Delete iterator
 static void s_nonconsensus_callback_atom_iter_delete(dap_chain_atom_iter_t * a_atom_iter); //    Get the fisrt event from gdb
@@ -375,7 +375,7 @@ static size_t s_nonconsensus_callback_atom_get_static_hdr_size()
  * @param a_chain dap_chain_t a_chain
  * @return dap_chain_atom_iter_t*
  */
-static dap_chain_atom_iter_t* s_nonconsensus_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from, bool a_show_forked_branches)
+static dap_chain_atom_iter_t* s_nonconsensus_callback_atom_iter_create(dap_chain_t * a_chain, dap_chain_cell_id_t a_cell_id, dap_hash_fast_t *a_hash_from)
 {
     dap_chain_atom_iter_t * l_iter = DAP_NEW_Z(dap_chain_atom_iter_t);
     if (!l_iter) {