diff --git a/modules/chain/CMakeLists.txt b/modules/chain/CMakeLists.txt
index 5fe8b539dcc847c86d712ba7af59274b526515df..67eb0f1512fc8620ea060a5cf34ab3ab45b81dc6 100644
--- a/modules/chain/CMakeLists.txt
+++ b/modules/chain/CMakeLists.txt
@@ -9,6 +9,7 @@ add_library(${PROJECT_NAME} STATIC ${DAP_CHAIN_SRCS} ${DAP_CHAIN_HEADERS})
 
 if(BUILD_CELLFRAME_SDK_TESTS)
     add_subdirectory(tests)
+    add_definitions("-DLEDGER_TEST_ENABLED")
 endif()
 
 #find_package(PkgConfig REQUIRED)
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index 8a18bfe2c288c4f40ba9e995345e20825b1bba9a..ff25acd063dc9f0692aa06009a80dc79354090a2 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -2907,7 +2907,7 @@ static int s_ledger_permissions_check(dap_chain_ledger_token_item_t *  a_token_i
         break;
     }
     if ( l_addrs && l_addrs_count){
-        if (a_data_size != sizeof (*l_addrs)){
+        if (a_data_size != sizeof (dap_chain_addr_t)){
             log_it(L_ERROR,"Wrong data size %zd for ledger permission check", a_data_size);
             return -2;
         }
@@ -3382,7 +3382,8 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
         if ( (l_token_item->flags & DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED ) ||  // If all is blocked - check if we're
              (l_token_item->flags & DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN) ){ // in white list
 
-            if(s_ledger_permissions_check(l_token_item, DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD,&l_tx_in_from,
+            if(!dap_chain_addr_is_blank(&l_tx_in_from) && s_ledger_permissions_check(l_token_item,
+                                           DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD,&l_tx_in_from,
                                           sizeof (l_tx_in_from)) != 0 ){
                 char * l_tmp_tx_in_from = dap_chain_addr_to_str(&l_tx_in_from);
                 if(s_debug_more)
@@ -3449,8 +3450,13 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
         if (!l_main_ticker)
             l_main_ticker = l_value_cur->token_ticker;
         HASH_ADD_STR(l_values_from_cur_tx, token_ticker, l_value_cur);
+#ifndef LEDGER_TEST_ENABLED
+        if (strcmp(l_token, PVT(a_ledger)->net_native_ticker) != 0)
+            return -78;
+#endif
     }
 
+
     // find 'out' items
     dap_list_t *l_list_out = dap_chain_datum_tx_items_get((dap_chain_datum_tx_t*) a_tx, TX_ITEM_TYPE_OUT_ALL, NULL);
     uint256_t l_value = {}, l_fee_sum = {};
@@ -3544,7 +3550,7 @@ int dap_chain_ledger_tx_cache_check(dap_ledger_t *a_ledger, dap_chain_datum_tx_t
 
         if ( (l_token_item->flags & DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED )||   //  If all is blocked or frozen
              (l_token_item->flags & DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN) ){ //  check if we're in white list
-            if(s_ledger_permissions_check(l_token_item, DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD,&l_tx_out_to ,
+            if(!dap_chain_addr_is_blank(&l_tx_out_to) && s_ledger_permissions_check(l_token_item, DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD,&l_tx_out_to ,
                                           sizeof (l_tx_out_to)) != 0 ){
                 char * l_tmp_tx_out_to = dap_chain_addr_to_str(&l_tx_out_to);
                 if(s_debug_more)
diff --git a/modules/chain/tests/dap_chain_ledger_tests.c b/modules/chain/tests/dap_chain_ledger_tests.c
index 2d3dedfa442a39beab45ceea7ab4aa59a40d289a..b361edd464fe7f287ac5e8ec6485c2532e1e4968 100644
--- a/modules/chain/tests/dap_chain_ledger_tests.c
+++ b/modules/chain/tests/dap_chain_ledger_tests.c
@@ -234,8 +234,11 @@ void dap_chain_ledger_test_write_back_list(dap_ledger_t *a_ledger, dap_cert_t *a
                                                                                       *l_addr_1->addr, a_cert);
         dap_hash_fast_t l_btx_addr1_hash = {0};
         dap_hash_fast(l_btx_addr1, dap_chain_datum_tx_get_size(l_btx_addr1), &l_btx_addr1_hash);
-        dap_assert_PIF(dap_chain_ledger_tx_add(a_ledger, l_btx_addr1, &l_btx_addr1_hash, false) == 1,
-                       "Can't added base tx in white address");
+        int l_ledger_add_code = dap_chain_ledger_tx_add(a_ledger, l_btx_addr1, &l_btx_addr1_hash, false);
+        char *l_ledger_tx_add_str = dap_strdup_printf("Can't added base tx in white address. Code: %d", l_ledger_add_code);
+        dap_assert_PIF(l_ledger_add_code == 1,
+                       l_ledger_tx_add_str);
+        DAP_DELETE(l_ledger_tx_add_str);
         dap_hash_fast_t l_tx_addr4_hash = {0};
         dap_chain_datum_tx_t *l_tx_to_addr4 = dap_chain_ledger_test_create_tx(l_addr_1->enc_key, &l_btx_addr1_hash,
                                                                               l_addr_4->addr, dap_chain_uint256_from(s_total_supply-s_fee));
@@ -421,6 +424,6 @@ void dap_chain_ledger_test_run(void){
     }	
     dap_chain_ledger_test_double_spending(l_ledger, &l_hash_btx, l_cert->enc_key, l_iddn);
     dap_chain_ledger_test_excess_supply(l_ledger, l_cert, &l_addr);
-    //dap_chain_ledger_test_write_back_list(l_ledger, l_cert, l_iddn);
+    dap_chain_ledger_test_write_back_list(l_ledger, l_cert, l_iddn);
 	
 }
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 0b74b8eb3fdc1f65db8143c6d00ebd6412d2707a..43623741f63d91337d74dd1268433c41c01fc12f 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -579,18 +579,81 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
             }
         }break;
         case SUBCMD_LIST:{
+                const char * l_hash_str = NULL;
+                const char * l_cert_name = NULL;
+                bool l_unspent_fl = false;
+                size_t l_block_count = 0;
+                dap_cert_t * l_cert = NULL;
+                dap_pkey_t * l_pub_key = NULL;
+
+                dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-cert", &l_cert_name);
+
+                if(l_cert_name) {
+
+                    l_cert = dap_cert_find_by_name( l_cert_name );
+                    if( l_cert == NULL ){
+                        dap_cli_server_cmd_set_reply_text(a_str_reply,
+                                "Can't find \"%s\" certificate", l_cert_name );
+                        return -18;
+                    }
+                    if( l_cert->enc_key == NULL ){
+                        dap_cli_server_cmd_set_reply_text(a_str_reply,
+                                "Corrupted certificate \"%s\" without keys certificate", l_cert_name );
+                        return -20;
+                    }
+                    if(l_cert) {
+                        l_pub_key = dap_pkey_from_enc_key(l_cert->enc_key);
+                    }
+                    if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-unspent", NULL))
+                        l_unspent_fl = true;
+                }
+
                 pthread_rwlock_rdlock(&PVT(l_blocks)->rwlock);
                 dap_string_t * l_str_tmp = dap_string_new(NULL);
-                dap_chain_block_cache_t * l_block_cache = NULL,*l_block_cache_tmp = NULL;
+                dap_chain_block_cache_t * l_block_cache = NULL,*l_block_cache_tmp = NULL;               
                 HASH_ITER(hh,PVT(l_blocks)->block_cache_first,l_block_cache, l_block_cache_tmp ) {
                     char l_buf[50];
                     time_t l_ts = l_block_cache->block->hdr.ts_created;
                     ctime_r(&l_ts, l_buf);
+                    dap_sign_t * l_sign = dap_chain_block_sign_get(l_block_cache->block, l_block_cache->block_size, 0);
+                    if(l_cert)
+                    {
+                        if(!dap_pkey_compare_with_sign(l_pub_key, l_sign))
+                            continue;
+                        if(l_unspent_fl){
+                            dap_chain_block_cache_tx_index_t *l_tx_cur, *l_tmp;
+                            //dap_chain_tx_out_cond_t *l_tx_out_cond = NULL;
+                            bool fl_found = false;
+                            HASH_ITER(hh, l_block_cache->tx_index, l_tx_cur, l_tmp)
+                            {
+                                int l_out_idx_tmp = 0;
+                                if (NULL == dap_chain_datum_tx_out_cond_get(l_tx_cur->tx, DAP_CHAIN_TX_OUT_COND_SUBTYPE_FEE,&l_out_idx_tmp))
+                                {
+                                    continue;
+                                }
+                                if(!dap_chain_ledger_tx_hash_is_used_out_item(l_net->pub.ledger,&l_tx_cur->tx_hash,l_out_idx_tmp))
+                                {
+                                    fl_found = true;
+                                    break;
+                                }
+                            }
+                            if(!fl_found)
+                                continue;
+                        }
+                    }
+
                     dap_string_append_printf(l_str_tmp,"\t%s: ts_create=%s",
-                                             l_block_cache->block_hash_str, l_buf);
+                                                 l_block_cache->block_hash_str, l_buf);
+                    l_block_count++;
                 }
-                dap_string_append_printf(l_str_tmp,"%s.%s: Have %"DAP_UINT64_FORMAT_U" blocks :\n",
-                                         l_net->pub.name,l_chain->name,PVT(l_blocks)->blocks_count);
+                if(l_cert){
+                    dap_string_append_printf(l_str_tmp,"%s.%s: Have %"DAP_UINT64_FORMAT_U" blocks signed with %s certificate :\n",
+                                             l_net->pub.name,l_chain->name,l_block_count,l_cert_name);
+                }
+                else
+                    dap_string_append_printf(l_str_tmp,"%s.%s: Have %"DAP_UINT64_FORMAT_U" blocks :\n",
+                                             l_net->pub.name,l_chain->name,PVT(l_blocks)->blocks_count);
+
                 pthread_rwlock_unlock(&PVT(l_blocks)->rwlock);
                 dap_cli_server_cmd_set_reply_text(a_str_reply, "%s", l_str_tmp->str);
                 dap_string_free(l_str_tmp, true);
@@ -609,10 +672,9 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
             dap_chain_addr_t        *l_addr = NULL;
 
             //arg_index++;
-            dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "collect", &str_tmp);
 
-            if(!str_tmp) {
-                dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'block' requires parameter 'fee collect'");
+            if(!dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "collect", NULL)) {
+                dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'block fee' requires parameter 'collect'");
                 return -14;
             }
             dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
@@ -680,7 +742,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
                 dap_chain_block_cache_t *l_block_cache = (dap_chain_block_cache_t *)bl->data;
                 dap_sign_t * l_sign = dap_chain_block_sign_get(l_block_cache->block, l_block_cache->block_size, 0);
                 if(!dap_pkey_compare_with_sign(l_pub_key, l_sign)){
-                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'block fee collect' requires parameter '-hashes'");
+                    dap_cli_server_cmd_set_reply_text(a_str_reply, "Block signature does not match certificate key");
                     dap_list_free(l_block_list);
                     return -23;
                 }