diff --git a/dap-sdk/core/include/dap_common.h b/dap-sdk/core/include/dap_common.h
index 548cdc52103ebb40c6ad44080dc69e60e2c7bd68..aaf3c1ef4bbb9e9e9a3cb4863a619f1beee035ea 100755
--- a/dap-sdk/core/include/dap_common.h
+++ b/dap-sdk/core/include/dap_common.h
@@ -58,6 +58,7 @@
 #include "portable_endian.h"
 typedef uint8_t byte_t;
 
+#define BIT( x ) ( 1 << x )
 // Stuffs an integer into a pointer type
 #define DAP_INT_TO_POINTER(i) ((void*) (long) (i))
 // Extracts an integer from a pointer
diff --git a/dap-sdk/core/include/dap_strfuncs.h b/dap-sdk/core/include/dap_strfuncs.h
index c530976c211ec59adb06d5ad016440259dee3ce1..95c80afc4ebe43b432e66206ea64b41c6096a063 100755
--- a/dap-sdk/core/include/dap_strfuncs.h
+++ b/dap-sdk/core/include/dap_strfuncs.h
@@ -63,6 +63,8 @@ char* dap_strjoin(const char *a_separator, ...);
 // split up string into max_tokens tokens at delimiter and return a newly allocated string array
 char** dap_strsplit(const char *a_string, const char *a_delimiter, int a_max_tokens);
 size_t dap_str_countv(char **a_str_array);
+size_t dap_str_symbol_count(const char *a_str, char a_sym);
+bool dap_str_remove_spaces(char *a_str);
 // copies a NULL-terminated array of strings
 char** dap_strdupv(const char **a_str_array);
 // frees the array itself and all of its strings.
diff --git a/dap-sdk/core/src/dap_strfuncs.c b/dap-sdk/core/src/dap_strfuncs.c
index 80336d36c92f1f2498bdf29ebe7f38ab2d854c37..db6107fe156bd539596d3fbe960e667bc87536a3 100755
--- a/dap-sdk/core/src/dap_strfuncs.c
+++ b/dap-sdk/core/src/dap_strfuncs.c
@@ -694,6 +694,18 @@ size_t dap_str_countv(char **a_str_array)
     return l_i;
 }
 
+size_t dap_str_symbol_count(const char *a_str, char a_sym)
+{
+   const char *p = a_str;
+   uint32_t l_count = 0;
+
+   while(*p){
+        if(p++ == a_sym) 
+            l_count++;
+   }
+   return l_count;
+}
+
 /**
  * @brief  dap_strdupv:
  * 
diff --git a/modules/chain/dap_chain_ledger.c b/modules/chain/dap_chain_ledger.c
index c0bfad6cf5748b4bb1eda1b26f31c72d018a0ef7..46fe5e973426b903fe7cd3cc0d2c8182dc1eea73 100644
--- a/modules/chain/dap_chain_ledger.c
+++ b/modules/chain/dap_chain_ledger.c
@@ -367,22 +367,44 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
     l_token_item = DAP_NEW_Z(dap_chain_ledger_token_item_t);
     dap_snprintf(l_token_item->ticker,sizeof (l_token_item->ticker), "%s", a_token->ticker);
     pthread_rwlock_init(&l_token_item->token_emissions_rwlock,NULL);
-    l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
-
-    //
-    // init current_supply value in token_declaration procedure (ledger cache and ledger memory object)
-    //
-
-    l_token_item->datum_token->header_private.current_supply = a_token->header_private.total_supply;
-    l_token_item->total_supply = a_token->header_private.total_supply_256;
 
-    l_token_item->current_supply = l_token_item->total_supply;
+    l_token_item->datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
+    l_token_item->datum_token_size = a_token_size;
+    l_token_item->type = a_token->type;
 
     memcpy(l_token_item->datum_token, a_token, a_token_size);
-
     dap_chain_datum_token_t *l_token_cache = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, a_token_size);
     memcpy(l_token_cache, a_token, a_token_size);
-    l_token_cache->header_private.current_supply_256 = l_token_item->total_supply;   
+
+    // init current_supply value in token_declaration procedure (ledger cache and ledger memory object)
+    // header_simple, header_token_private, header_token_
+     switch(a_token->type){
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:
+            l_token_item->datum_token->header_simple.current_supply_256 = a_token->header_simple.total_supply_256;
+            l_token_item->total_supply = a_token->header_simple.total_supply_256;    
+            l_token_item->current_supply = a_token->header_simple.total_supply_256;
+            l_token_item->auth_signs_total = a_token->header_simple.signs_total;
+            l_token_item->auth_signs_valid = a_token->header_simple.signs_valid;
+            l_token_cache->header_simple.current_supply_256 = l_token_item->total_supply;   
+        break;
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:
+            l_token_item->datum_token->header_private_decl.current_supply_256 = a_token->header_private_decl.total_supply_256;
+            l_token_item->total_supply = a_token->header_private_decl.total_supply_256;    
+            l_token_item->current_supply = a_token->header_private_decl.total_supply_256;
+            l_token_item->auth_signs_total = a_token->header_private_decl.signs_total;
+            l_token_item->auth_signs_valid = a_token->header_private_decl.signs_valid;
+            l_token_cache->header_private_decl.current_supply_256 = l_token_item->total_supply;   
+        break;
+            case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL:
+            l_token_item->datum_token->header_native_decl.current_supply_256 = a_token->header_native_decl.total_supply_256;
+            l_token_item->total_supply = a_token->header_native_decl.total_supply_256;    
+            l_token_item->current_supply = a_token->header_native_decl.total_supply_256;
+            l_token_item->auth_signs_total = a_token->header_native_decl.signs_total;
+            l_token_item->auth_signs_valid = a_token->header_native_decl.signs_valid;
+            l_token_cache->header_native_decl.current_supply_256 = l_token_item->total_supply;   
+        default:
+        break;
+     }
 
     pthread_rwlock_wrlock(&PVT(a_ledger)->tokens_rwlock);
     HASH_ADD_STR(PVT(a_ledger)->tokens, ticker, l_token_item);
@@ -395,12 +417,8 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
             log_it(L_WARNING, "Ledger cache mismatch");
     }
     DAP_DELETE(l_gdb_group);
-
-    l_token_item->type = a_token->type;
     switch(a_token->type){
         case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: {// 256
-            l_token_item->total_supply = a_token->header_private.total_supply_256;
-            l_token_item->current_supply = l_token_item->total_supply;
             l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
                                                                                        &l_token_item->auth_signs_total,
                                                                                        &l_token_item->auth_signs_valid );
@@ -411,14 +429,12 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
                 }
                 if(s_debug_more)
                     log_it(L_NOTICE, "Simple token %s added (total_supply = %s total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE )",
-                       a_token->ticker, dap_chain_balance_to_coins(a_token->header_private.total_supply_256),
-                       a_token->header_private.signs_valid, a_token->header_private.signs_total);
+                       a_token->ticker, dap_chain_balance_to_coins(a_token->header_simple.total_supply_256),
+                       a_token->header_simple.signs_valid, a_token->header_simple.signs_total);
             }
             break;
         }
         case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
-            l_token_item->total_supply = a_token->header_private.total_supply_256;
-            l_token_item->current_supply = l_token_item->total_supply;
             l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
                                                                                        &l_token_item->auth_signs_total,
                                                                                        &l_token_item->auth_signs_valid );
@@ -429,17 +445,12 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
                 }
                 if(s_debug_more)
                     log_it(L_NOTICE, "Simple token %s added (total_supply = %.1Lf total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE )",
-                       a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_private.total_supply),
-                       a_token->header_private.signs_valid, a_token->header_private.signs_total);
+                       a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_simple.total_supply),
+                       a_token->header_simple.signs_valid, a_token->header_simple.signs_total);
             }
             break;
         }
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
-            if(s_debug_more)
-                log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL ", a_token->ticker);
-            l_token_item->total_supply = a_token->header_private.total_supply_256;
-            l_token_item->current_supply = a_token->header_private.current_supply_256;
-            
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256         
             l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
                                                                                     &l_token_item->auth_signs_total,
                                                                                     &l_token_item->auth_signs_valid );
@@ -449,27 +460,33 @@ int dap_chain_ledger_token_add(dap_ledger_t *a_ledger, dap_chain_datum_token_t *
                     dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
                 }
                 if(s_debug_more)
-                    log_it(L_NOTICE, "Simple token %s added (total_supply = %.1Lf total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE)",
-                    a_token->ticker, dap_chain_datoshi_to_coins(a_token->header_private.total_supply),
-                    a_token->header_private.signs_valid, a_token->header_private.signs_total);
+                    log_it(L_NOTICE, "Private token %s added (total_supply = %s total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL)",
+                    a_token->ticker, dap_chain_balance_to_coins(a_token->header_private_decl.total_supply_256),
+                    a_token->header_private_decl.signs_valid, a_token->header_private_decl.signs_total);
             }
             s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
             break;
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL: {
-            if(s_debug_more)
-                log_it( L_NOTICE, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL ", a_token->ticker);
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL: // 256          
+            l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(a_token,a_token_size,
+                                                                                    &l_token_item->auth_signs_total,
+                                                                                    &l_token_item->auth_signs_valid );
+            if(l_token_item->auth_signs_total){
+                l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,sizeof (dap_chain_hash_fast_t)* l_token_item->auth_signs_total);
+                for(uint16_t k=0; k<l_token_item->auth_signs_total;k++){
+                    dap_sign_get_pkey_hash(l_token_item->auth_signs[k],&l_token_item->auth_signs_pkey_hash[k]);
+                }
+                if(s_debug_more)
+                    log_it(L_NOTICE, "Native token %s added (total_supply = %s total_signs_valid=%hu signs_total=%hu type=DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL)",
+                    a_token->ticker, dap_chain_balance_to_coins(a_token->header_native_decl.total_supply_256),
+                    a_token->header_native_decl.signs_valid, a_token->header_native_decl.signs_total);
+            }
             s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
             break;
-        }
         case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
             if(s_debug_more)
                 log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
-            break;
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
-            if(s_debug_more)
-                log_it( L_WARNING, "Private token %s type=DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE. Not processed, wait for software update", a_token->ticker);
-                    // TODO: Check authorithy
-                    //s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
+                // TODO: Check authorithy
+                //s_token_tsd_parse(a_ledger,l_token_item, a_token, a_token_size);
             break;
         default:
             if(s_debug_more)
@@ -577,9 +594,11 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
             //Allowed tx receiver addres list add, remove or clear
             case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:{
                 if( l_tsd->size == sizeof (dap_chain_addr_t) ){
-                    dap_chain_addr_t * l_addrs = a_token_item->tx_recv_allow? DAP_NEW_Z_SIZE( dap_chain_addr_t,
-                                                                                              sizeof(*a_token_item->tx_recv_allow) )
-                                : DAP_REALLOC(a_token_item->tx_recv_allow,(a_token_item->tx_recv_allow_size+1)*sizeof (*a_token_item->tx_recv_allow) );
+
+                    if (a_token_item->tx_recv_allow)
+                        a_token_item->tx_recv_allow = DAP_REALLOC(a_token_item->tx_recv_allow,(a_token_item->tx_recv_allow_size+1)*sizeof (*a_token_item->tx_recv_allow));
+                    else
+                        a_token_item->tx_recv_allow = DAP_NEW_Z_SIZE( dap_chain_addr_t,sizeof(*a_token_item->tx_recv_allow));
 
                     // Check if its correct
                     dap_chain_addr_t * l_add_addr = (dap_chain_addr_t *) l_tsd->data;
@@ -588,7 +607,6 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
                         if(s_debug_more)
                             log_it(L_ERROR,"Wrong address checksum in TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD (code %d)",
                                l_add_addr_check);
-                        DAP_DELETE(l_addrs);
                         return -12;
                     }
                     // Check if its already present
@@ -599,19 +617,18 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
                                 if(s_debug_more)
                                     log_it(L_ERROR,"TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD has address %s thats already present in list",
                                        l_addr_str);
-                                DAP_DELETE(l_addr_str);
-                                DAP_DELETE(l_addrs);
+                                DAP_DELETE(l_addr_str);     
+                                DAP_DELETE(a_token_item->tx_recv_allow);
+                                a_token_item->tx_recv_allow = NULL;
                                 return -11;
                             }
                         }
-                    if( l_addrs){
-                        memcpy(&l_addrs[a_token_item->tx_recv_allow_size], l_tsd->data,l_tsd->size);
-                        a_token_item->tx_recv_allow_size++;
-                        a_token_item->tx_recv_allow = l_addrs;
+                        if(a_token_item->tx_recv_allow){
+                            memcpy(&a_token_item->tx_recv_allow[a_token_item->tx_recv_allow_size], l_tsd->data,l_tsd->size);
+                            a_token_item->tx_recv_allow_size++;
 
                     }else{
                         log_it(L_ERROR,"Out of memory! Can't extend TX_RECEIVER_ALLOWED array");
-                        DAP_DELETE(l_addrs);
                         return -20;
                     }
                 }else{
@@ -691,7 +708,8 @@ static int s_token_tsd_parse(dap_ledger_t * a_ledger, dap_chain_ledger_token_ite
                                     log_it(L_ERROR,"TSD param DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD has address %s thats already present in list",
                                        l_addr_str);
                                 DAP_DELETE(l_addr_str);
-                                DAP_DELETE(l_addrs);
+                                DAP_DELETE(a_token_item->tx_recv_allow);
+                                a_token_item->tx_recv_allow = NULL;
                                 return -11;
                             }
                         }
@@ -954,16 +972,19 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger)
     pthread_rwlock_rdlock(&PVT(a_ledger)->tokens_rwlock);
     HASH_ITER(hh, PVT(a_ledger)->tokens, l_token_item, l_tmp_item) {
         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_SIMPLE: // 256
             case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
                 l_type_str = "SIMPLE"; break;
             case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
-                l_type_str = "PRIVATE_DECL"; break;
+                l_type_str = "PRIVATE"; break;
             case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
                 l_type_str = "PRIVATE_UPDATE"; break;
+            case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL: // 256
+                l_type_str = "NATIVE"; break;
+            case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE: // 256
+                l_type_str = "NATIVE_UPDATE"; break;
             case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: // 256
             case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC:
                 l_type_str = "PUBLIC";
@@ -972,8 +993,7 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger)
         }
        char *l_item_str = NULL;
 
-            if ((l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL) | (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE)){
-                l_item_str = dap_strdup_printf("Token name '%s', type %s, flags: %s\n"
+       l_item_str = dap_strdup_printf("Token name '%s', type %s, flags: %s\n"
                                                 "\tSupply (current/total) %s/%s\n"
                                                 "\tAuth signs (valid/total) %zu/%zu\n"
                                                 "\tTotal emissions %u\n",
@@ -981,17 +1001,6 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger)
                                                 dap_chain_balance_print(l_token_item->current_supply), dap_chain_balance_print(l_token_item->total_supply),
                                                 l_token_item->auth_signs_valid, l_token_item->auth_signs_total,
                                                 HASH_COUNT(l_token_item->token_emissions));
-            } 
-            else{
-                l_item_str = dap_strdup_printf("Token name '%s', type %s, flags: %hu\n"
-                                                "\tSupply (current/total) %s/%s\n"
-                                                "\tAuth signs (valid/total) %zu/%zu\n"
-                                                "\tTotal emissions %u\n",
-                                                &l_token_item->ticker, l_type_str, l_token_item->datum_token->header_private_decl.flags,
-                                                dap_chain_balance_print(l_token_item->current_supply), dap_chain_balance_print(l_token_item->total_supply),
-                                                l_token_item->auth_signs_valid, l_token_item->auth_signs_total,
-                                                HASH_COUNT(l_token_item->token_emissions));
-            }
 
         l_ret_list = dap_list_append(l_ret_list, l_item_str);
     }
@@ -1011,23 +1020,36 @@ dap_list_t *dap_chain_ledger_token_info(dap_ledger_t *a_ledger)
 bool s_update_token_cache(dap_ledger_t *a_ledger, dap_chain_ledger_token_item_t * l_token_item, uint256_t l_emission_value)
 {
     //Update value in ledger memory object
-    if (compare256(l_token_item->current_supply, l_emission_value) >= 0) {
+
+    if (s_token_supply_limit_disable){
+        log_it(L_WARNING,"s_token_supply_limit_disable is enabled in config, please fix it and disable");
+        return false;
+    }
+
+    if (compare256(l_token_item->current_supply, l_emission_value)>= 0){
         SUBTRACT_256_256(l_token_item->current_supply, l_emission_value, &l_token_item->current_supply);
         log_it(L_DEBUG,"New current supply %s for token %s",
-               dap_chain_balance_print(l_token_item->current_supply), l_token_item->ticker);
+            dap_chain_balance_print(l_token_item->current_supply), l_token_item->ticker);
     } else {
-       log_it(L_WARNING,"Token current supply %s lower, than emission value = %s",
-              dap_chain_balance_print(l_token_item->current_supply),
+            log_it(L_WARNING,"Token current supply %s lower, than emission value = %s",
+                dap_chain_balance_print(l_token_item->current_supply),
                                         dap_chain_balance_print(l_emission_value));
-       return false;
-    }   
+            return false;
+    }
+    //if load mode, we don't save anything
+    if (PVT(a_ledger)->load_mode)
+        return true;
+    // if cache mode disable we can't read something from GDB
+    if (!dap_config_get_item_bool_default(g_config, "ledger", "cached", true)) 
+        return true;
+
     // load ledger cache from GDB
     // Get dap_chain_datum_token_t token object from GDB, key is token name
     char *l_gdb_group = dap_chain_ledger_get_gdb_group(a_ledger, DAP_CHAIN_LEDGER_TOKENS_STR);
     size_t l_obj_length = 0;
     dap_chain_datum_token_t *l_token_cache = (dap_chain_datum_token_t *)
             dap_chain_global_db_gr_get(l_token_item->ticker, &l_obj_length, l_gdb_group);
-    l_token_cache->header_private.current_supply_256 = l_token_item->current_supply;
+    l_token_cache->header_simple.current_supply_256 = l_token_item->current_supply;
     if (!dap_chain_global_db_gr_set(l_token_item->ticker, l_token_cache, l_obj_length, l_gdb_group)) {
         if(s_debug_more)
             log_it(L_WARNING, "Ledger cache mismatch");
@@ -1123,18 +1145,63 @@ void dap_chain_ledger_load_cache(dap_ledger_t *a_ledger)
         // printf("---!!! dap_chain_ledger_load_cache() sign_type %d \n", ( (dap_sign_t *)sign[0])->header.type.type );
 
         if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE) {
-            l_token_item->total_supply = GET_256_FROM_64(l_token_item->datum_token->header_private.total_supply);
-            l_token_item->current_supply = l_token_item->total_supply;
-        }  else if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE) {
-            l_token_item->total_supply = l_token_item->datum_token->header_private.total_supply_256;
+            l_token_item->total_supply = GET_256_FROM_64(l_token_item->datum_token->header_simple.total_supply);
+            l_token_item->current_supply = GET_256_FROM_64(l_token_item->datum_token->header_simple.current_supply);
+            l_token_item->auth_signs_total = l_token_item->datum_token->header_simple.signs_total;
+            l_token_item->auth_signs_valid = l_token_item->datum_token->header_simple.signs_valid;
+        }  else if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE) 
+        {
+            l_token_item->total_supply = l_token_item->datum_token->header_simple.total_supply_256;
+            l_token_item->current_supply = l_token_item->datum_token->header_simple.current_supply_256;
+            l_token_item->auth_signs_total = l_token_item->datum_token->header_simple.signs_total;
+            l_token_item->auth_signs_valid = l_token_item->datum_token->header_simple.signs_valid;
+            if (l_token_item->auth_signs_total) 
+            {
+                l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,
+                                                                    sizeof(dap_chain_hash_fast_t) * l_token_item->auth_signs_total);
+                l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(l_token_item->datum_token,l_token_item->datum_token_size,
+                                                                                    &l_token_item->auth_signs_total,
+                                                                                    &l_token_item->auth_signs_valid );
+                for (uint16_t k=0; k < l_token_item->auth_signs_total; k++) {
+                    dap_sign_get_pkey_hash(l_token_item->auth_signs[k], &l_token_item->auth_signs_pkey_hash[k]);
+                }
+            }
+        } else if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL) 
+        {
+            l_token_item->total_supply = l_token_item->datum_token->header_private_decl.total_supply_256;
+            l_token_item->current_supply = l_token_item->datum_token->header_private_decl.current_supply_256;
+            l_token_item->auth_signs_total = l_token_item->datum_token->header_private_decl.signs_total;
+            l_token_item->auth_signs_valid = l_token_item->datum_token->header_private_decl.signs_valid;
             if (l_token_item->auth_signs_total) {
                 l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,
                                                                     sizeof(dap_chain_hash_fast_t) * l_token_item->auth_signs_total);
+
+                l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(l_token_item->datum_token,l_token_item->datum_token_size,
+                                                                                    &l_token_item->auth_signs_total,
+                                                                                    &l_token_item->auth_signs_valid );
+                for (uint16_t k=0; k < l_token_item->auth_signs_total; k++) {
+                    dap_sign_get_pkey_hash(l_token_item->auth_signs[k], &l_token_item->auth_signs_pkey_hash[k]);
+                }
+            }
+        } else if (l_token_item->datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL) 
+        {
+            l_token_item->total_supply = l_token_item->datum_token->header_native_decl.total_supply_256;
+            l_token_item->current_supply = l_token_item->datum_token->header_native_decl.current_supply_256;
+            l_token_item->auth_signs_total = l_token_item->datum_token->header_native_decl.signs_total;
+            l_token_item->auth_signs_valid = l_token_item->datum_token->header_native_decl.signs_valid;
+            if (l_token_item->auth_signs_total) {
+                l_token_item->auth_signs_pkey_hash = DAP_NEW_Z_SIZE(dap_chain_hash_fast_t,
+                                                                    sizeof(dap_chain_hash_fast_t) * l_token_item->auth_signs_total);
+
+                l_token_item->auth_signs= dap_chain_datum_token_simple_signs_parse(l_token_item->datum_token,l_token_item->datum_token_size,
+                                                                                    &l_token_item->auth_signs_total,
+                                                                                    &l_token_item->auth_signs_valid );
                 for (uint16_t k=0; k < l_token_item->auth_signs_total; k++) {
                     dap_sign_get_pkey_hash(l_token_item->auth_signs[k], &l_token_item->auth_signs_pkey_hash[k]);
                 }
             }
         }
+
         HASH_ADD_STR(l_ledger_pvt->tokens, ticker, l_token_item);
     }
     dap_chain_global_db_objs_delete(l_objs, l_objs_count);
@@ -1241,27 +1308,69 @@ dap_ledger_t* dap_chain_ledger_create(uint16_t a_check_flags, char *a_net_name)
     return l_ledger;
 }
 
+/**
+ * @brief 
+ * 
+ * @param l_add_addr01 
+ * @param l_add_addr02 
+ * @return true 
+ * @return false 
+ */
+bool s_chain_compare_token_addresses(dap_chain_addr_t * l_add_addr01, dap_chain_addr_t * l_add_addr02)
+{
+    if (!l_add_addr01 || !l_add_addr02)
+        return false;
+
+    //0 if equal
+    if (!memcmp(l_add_addr01,l_add_addr02,sizeof(dap_chain_addr_t)))
+        return true;
+    
+    return false;
+}
+
 bool s_chain_ledger_token_tsd_check(dap_chain_ledger_token_item_t * l_token_item, dap_chain_datum_token_emission_t *a_token_emission)
 {
     // for multiple tsd we need to parse every tsd in cycle
     if (!l_token_item){
-        log_it(L_WARNING, "Token object is null. Probably, you set unknown token ticker in -token parameter");
+        log_it(L_WARNING, "Token object is null. Probably, you set unknown token ticker in -token parameter of command");
         return false;
     }
+    //get fir tsd for next tsd getting
     dap_tsd_t *l_tsd = dap_chain_datum_token_tsd_get(l_token_item->datum_token, l_token_item->datum_token_size);
     if (!l_tsd)
         return false;
-    switch(l_tsd->type){
-        case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
-            if (memcmp(&a_token_emission->hdr.address, (dap_chain_addr_t *)l_tsd->data, sizeof(dap_chain_addr_t))) {
-                log_it(L_WARNING, "Address %s is not allowed for emission for token %s",
-                       dap_chain_addr_to_str(&a_token_emission->hdr.address), l_token_item->ticker);
-                return false;
-            }
-        default: break;
-    }
-    log_it(L_WARNING, "Private tokens limitations were checked successful");
-    return true;
+    
+    dap_chain_addr_t *l_add_addr = NULL;
+    size_t l_tsd_size=0;
+    size_t l_tsd_total_size = l_token_item->datum_token->header_private_decl.tsd_total_size;
+
+    for( size_t l_offset=0; l_offset < l_tsd_total_size;  l_offset += l_tsd_size ){
+        l_tsd = (dap_tsd_t *) (((byte_t*)l_tsd ) +l_offset);
+        l_tsd_size = l_tsd? dap_tsd_size(l_tsd): 0;
+        if(l_tsd_size==0){
+            if(s_debug_more)
+                log_it(L_ERROR,"Wrong zero TSD size, exiting TSD parse");
+            break;
+        } else if (l_tsd_size + l_offset > l_tsd_total_size){
+            if(s_debug_more)
+                log_it(L_ERROR,"Wrong %zd TSD size, exiting TSD parse", l_tsd_size);
+            break;
+        }
+
+        switch(l_tsd->type){
+            case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
+                l_add_addr = (dap_chain_addr_t *) l_tsd->data;
+                if (s_chain_compare_token_addresses(&a_token_emission->hdr.address, l_add_addr)){
+                    log_it(L_DEBUG, "Private tokens limitations for DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD flag were checked successfully");
+                    return true;
+                }
+                break;
+            default:
+                break;
+        }
+    } 
+    log_it(L_WARNING, "Address %s is not allowed for emission for token %s", dap_chain_addr_to_str(&a_token_emission->hdr.address), l_token_item->ticker);
+    return false;
 }
 
 int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_token_emission, size_t a_token_emission_size)
@@ -1311,11 +1420,19 @@ int dap_chain_ledger_token_emission_add_check(dap_ledger_t *a_ledger, byte_t *a_
     // Check emission correctness
     size_t l_emission_size = a_token_emission_size;
     dap_chain_datum_token_emission_t *l_emission = dap_chain_datum_emission_read(a_token_emission, &l_emission_size);
+
+    if (!l_token_item){
+        log_it(L_WARNING,"Ledger_token_emission_add_check. Token ticker %s was not found",c_token_ticker);
+        return -5;
+    }
+
     if (compare256(l_token_item->current_supply, l_emission->hdr.value_256) < 0)
         return -4;
     //additional check for private tokens
     if ((l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL) ||
-            (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE)) {
+            (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE) || 
+            (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL) ||
+             (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE)) {
         if (!s_chain_ledger_token_tsd_check(l_token_item, l_emission))
                 return -5;
     }
@@ -1388,6 +1505,7 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
     dap_chain_ledger_token_emission_item_t * l_token_emission_item = NULL; 
     if (!l_token_item && a_from_threshold)
         return DAP_CHAIN_CS_VERIFY_CODE_TX_NO_TOKEN;
+
     // check if such emission is already present in table
     pthread_rwlock_rdlock( l_token_item ? &l_token_item->token_emissions_rwlock
                                         : &l_ledger_priv->threshold_emissions_rwlock);
@@ -1403,30 +1521,18 @@ int dap_chain_ledger_token_emission_add(dap_ledger_t *a_ledger, byte_t *a_token_
         if (l_token_item) {
             l_token_emission_item->datum_token_emission = dap_chain_datum_emission_read(a_token_emission,
                                                                                         &l_token_emission_item->datum_token_emission_size);
-            //  update current_supply in ledger cache and ledger memory object
-            if (!PVT(a_ledger)->load_mode && l_token_item && !s_token_supply_limit_disable)
-                if (!s_update_token_cache(a_ledger, l_token_item, l_token_emission_item->datum_token_emission->hdr.value_256))
-                   return -4;
 
-            // if cache is disabled, we need calc tokens manually
-            if (PVT(a_ledger)->load_mode)
-            {
-                if (!dap_config_get_item_bool_default(g_config, "ledger", "cached", true)) {
-
-                    if (compare256(l_token_item->current_supply, l_token_emission_item->datum_token_emission->hdr.value_256) >= 0) {
-                        SUBTRACT_256_256(l_token_item->current_supply, l_token_emission_item->datum_token_emission->hdr.value_256, &l_token_item->current_supply);
-                        log_it(L_DEBUG,"New current supply %s for token %s",
-                            dap_chain_balance_print(l_token_item->current_supply), l_token_item->ticker);
-                    } else {
-                    log_it(L_WARNING,"Token current supply %s lower, than emission value = %s",
-                            dap_chain_balance_print(l_token_item->current_supply),
-                                                        dap_chain_balance_print(l_token_emission_item->datum_token_emission->hdr.value_256));
-                        return -4;
-                    }  
-                }
-            }   
-            if (s_token_supply_limit_disable)
-                log_it(L_WARNING,"s_token_supply_limit_disable is enabled in config, please fix it and disable");
+                                                                                            //additional check for private tokens
+        if ((l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL) ||
+                (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE) || 
+                (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL) ||
+                (l_token_item->type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE)) {
+            if (!s_chain_ledger_token_tsd_check(l_token_item, (dap_chain_datum_token_emission_t *)a_token_emission))
+                return -114;
+        }
+            //update current_supply in ledger cache and ledger memory object
+        if (!s_update_token_cache(a_ledger, l_token_item, l_token_emission_item->datum_token_emission->hdr.value_256))
+                 return -4;
 
             pthread_rwlock_wrlock(&l_token_item->token_emissions_rwlock);
             HASH_ADD(hh, l_token_item->token_emissions, datum_token_emission_hash,
diff --git a/modules/common/dap_chain_datum_token.c b/modules/common/dap_chain_datum_token.c
index 1b9313d6b8dff4a8b8677b86d592126686dd559b..46a357606d73c129c0111dc4fbb044ac2759d7d6 100644
--- a/modules/common/dap_chain_datum_token.c
+++ b/modules/common/dap_chain_datum_token.c
@@ -74,14 +74,20 @@ dap_tsd_t* dap_chain_datum_token_tsd_get(dap_chain_datum_token_t *a_token, size_
     switch( a_token->type){
         case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
             l_hdr_size = sizeof(dap_chain_datum_token_t);
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
             l_tsd_size = a_token->header_private_decl.tsd_total_size;
             break;
         case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
             l_hdr_size = sizeof(dap_chain_datum_token_t);
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
             l_tsd_size = a_token->header_private_update.tsd_total_size;
             break;
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL: // 256
+            l_hdr_size = sizeof(dap_chain_datum_token_t);
+            l_tsd_size = a_token->header_native_decl.tsd_total_size;
+            break;
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE: // 256
+            l_hdr_size = sizeof(dap_chain_datum_token_t);
+            l_tsd_size = a_token->header_native_update.tsd_total_size;
+            break;
         default: return NULL;
     }
 
@@ -125,21 +131,11 @@ dap_chain_datum_token_t *dap_chain_datum_token_read(byte_t *a_token_serial, size
         switch( l_token_type ){
             case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE: {
                 l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
-                l_token->header_private.total_supply_256 = GET_256_FROM_64(l_token_old->header_private.total_supply);
-                l_token->header_private.signs_valid = l_token_old->header_private.signs_valid;
-                l_token->header_private.signs_total = l_token_old->header_private.signs_total;
+                l_token->header_simple.total_supply_256 = GET_256_FROM_64(l_token_old->header_simple.total_supply);
+                l_token->header_simple.signs_valid = l_token_old->header_simple.signs_valid;
+                l_token->header_simple.signs_total = l_token_old->header_simple.signs_total;
                 break;
             }
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
-                    l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL; // 256
-                    l_token->header_private_decl.flags = l_token_old->header_private_decl.flags;
-                    l_token->header_private_decl.tsd_total_size = l_token_old->header_private_decl.tsd_total_size;
-                 break;
-            case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
-                    l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE; // 256
-                    l_token->header_private_update.padding = l_token_old->header_private_update.padding;
-                    l_token->header_private_update.tsd_total_size = l_token_old->header_private_update.tsd_total_size;
-                break;
             case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC:
                     l_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC; // 256
                     l_token->header_public.total_supply_256 = GET_256_FROM_128(l_token_old->header_public.total_supply);
@@ -227,16 +223,16 @@ dap_sign_t ** dap_chain_datum_token_simple_signs_parse(dap_chain_datum_token_t *
     assert(a_signs_total);
     assert(a_signs_valid);
     assert(a_datum_token_size >= sizeof(dap_chain_datum_token_old_t));
-    dap_sign_t ** l_ret = DAP_NEW_Z_SIZE(dap_sign_t*, sizeof (dap_sign_t*)*a_datum_token->header_private.signs_total );
+    dap_sign_t ** l_ret = DAP_NEW_Z_SIZE(dap_sign_t*, sizeof (dap_sign_t*)*a_datum_token->header_simple.signs_total );
     *a_signs_total=0;
-    *a_signs_valid = a_datum_token->header_private.signs_valid;
+    *a_signs_valid = a_datum_token->header_simple.signs_valid;
     size_t l_offset = 0;
     uint16_t n = 0;
     size_t l_signs_offset = a_datum_token->type == DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE
                                                  ? sizeof(dap_chain_datum_token_old_t)
                                                  : sizeof(dap_chain_datum_token_t);
 
-    while( l_offset < (a_datum_token_size - l_signs_offset) && n < a_datum_token->header_private.signs_total ) {
+    while( l_offset < (a_datum_token_size - l_signs_offset) && n < a_datum_token->header_simple.signs_total ) {
         dap_sign_t *l_sign = (dap_sign_t *)((byte_t *)a_datum_token + l_signs_offset + l_offset);
         size_t l_sign_size = dap_sign_get_size(l_sign);
         if(!l_sign_size ){
@@ -335,8 +331,6 @@ dap_chain_datum_token_emission_t *dap_chain_datum_emission_read(byte_t *a_emissi
 bool dap_chain_datum_token_is_old(uint8_t a_type) {
     switch(a_type) {
         case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
-        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
         case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC:
             return true;
         default:
diff --git a/modules/common/include/dap_chain_datum_token.h b/modules/common/include/dap_chain_datum_token.h
index b208c06f9ca8e2faa97ae18cc5179f6f03898f34..bc791ce7b784bf6584127dcdd91da04146b4f1cd 100644
--- a/modules/common/include/dap_chain_datum_token.h
+++ b/modules/common/include/dap_chain_datum_token.h
@@ -41,7 +41,7 @@ typedef struct dap_chain_datum_token_old {
             uint64_t total_supply;
             uint16_t signs_valid;
             uint16_t signs_total;
-        } DAP_ALIGN_PACKED header_private;
+        } DAP_ALIGN_PACKED header_simple;
         struct {
             uint16_t flags;
             size_t tsd_total_size;
@@ -66,7 +66,7 @@ typedef struct dap_chain_datum_token{
     uint16_t type;
     char ticker[DAP_CHAIN_TICKER_SIZE_MAX];
     union {
-        // Simple private token declaration. Useful for 100% premined emission without any plays with token and owners after that
+        // Simple token declaration. Useful for 100% premined emission without any plays with token and owners after that
         struct {
             union {
                 uint64_t total_supply; // Could be zero if unlimited
@@ -78,17 +78,49 @@ typedef struct dap_chain_datum_token{
             };
             uint16_t signs_valid; // Emission auth signs
             uint16_t signs_total; // Emission auth signs
-        } DAP_ALIGN_PACKED header_private;
+            uint16_t padding01; // Token declaration flags
+            uint64_t padding02; 
+        } DAP_ALIGN_PACKED header_simple;
         // Private token declarations, with flags, manipulations and updates
         struct {
+            union {
+                uint64_t total_supply; // Could be zero if unlimited
+                uint256_t total_supply_256;
+            };
+            union {
+                uint64_t current_supply; // Could be zero if unlimited
+                uint256_t current_supply_256;
+            };
+            uint16_t signs_valid; // Emission auth signs
+            uint16_t signs_total; // Emission auth signs
             uint16_t flags; // Token declaration flags
             size_t tsd_total_size; // Data size section with values in key-length-value list trailing the signs section
         } DAP_ALIGN_PACKED header_private_decl;
+        //native tokens
+        struct {
+            union {
+                uint64_t total_supply; // Could be zero if unlimited
+                uint256_t total_supply_256;
+            };
+            union {
+                uint64_t current_supply; // Could be zero if unlimited
+                uint256_t current_supply_256;
+            };
+            uint16_t signs_valid; // Emission auth signs
+            uint16_t signs_total; // Emission auth signs
+            uint16_t flags; // Token declaration flags
+            size_t tsd_total_size; // Data size section with values in key-length-value list trailing the signs section
+        } DAP_ALIGN_PACKED header_native_decl;
         // Private token update
         struct {
             uint16_t padding;
             size_t tsd_total_size; // Data size section with extended values in key-length-value list.
         } DAP_ALIGN_PACKED header_private_update;
+        // native token update
+        struct {
+            uint16_t padding;
+            size_t tsd_total_size; // Data size section with extended values in key-length-value list.
+        } DAP_ALIGN_PACKED header_native_update;
         // Public token declaration
         struct {
             union {
@@ -102,7 +134,7 @@ typedef struct dap_chain_datum_token{
             dap_chain_addr_t premine_address;
             uint32_t flags;
         } DAP_ALIGN_PACKED header_public;
-        byte_t free_space[256]; // For future changes
+        byte_t free_space[152]; // For future changes
     };
     byte_t data_n_tsd[]; // Signs and/or types-size-data sections
 } DAP_ALIGN_PACKED dap_chain_datum_token_t;
@@ -111,9 +143,9 @@ typedef struct dap_chain_datum_token{
 // Simple private token decl
 #define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE           0x0001
 // Extended declaration of privatetoken with in-time control
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL     0x0002
+//#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL     0x0002
 // Token update
-#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE   0x0003
+//#define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE   0x0003
 // Open token with now ownership
 #define DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PUBLIC           0x0004
 
@@ -126,6 +158,11 @@ typedef struct dap_chain_datum_token{
 #define DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE       0x0007
 // Open token with now ownership
 #define DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC               0x0008
+// Native token type
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL          0x0009
+// Token update
+#define DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE        0x000A
+// Open token with now ownership
 
 
 // Macros for token flags
@@ -133,44 +170,44 @@ typedef struct dap_chain_datum_token{
 // No any flags
 #define DAP_CHAIN_DATUM_TOKEN_FLAG_NONE                                           0x0000
 // Blocked all permissions, usefull issue it by default and then allow what you want to allow
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED                             1 << 1
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_BLOCKED                             BIT(1)
 // Allowed all permissions if not blocked them. Be careful with this mode
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED                             1 << 2
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_ALLOWED                             BIT(2)
 // All permissions are temprorary frozen
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN                              1 << 3
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_FROZEN                              BIT(3)
 // Unfrozen permissions
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN                            1 << 4
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_SENDER_UNFROZEN                            BIT(4)
 
 // Blocked all permissions, usefull issue it by default and then allow what you want to allow
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED                             1 << 5
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_BLOCKED                             BIT(5)
 // Allowed all permissions if not blocked them. Be careful with this mode
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED                             1 << 6
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_ALLOWED                             BIT(6)
 // All permissions are temprorary frozen
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN                              1 << 7
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_FROZEN                              BIT(7)
 // Unfrozen permissions
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN                            1 << 8
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_ALL_RECEIVER_UNFROZEN                            BIT(8)
 
 /// ------ Static configured flags
 // No token manipulations after declarations at all. Token declares staticly and can't variabed after
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL                              1 << 9
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_ALL                              BIT(9)
 
 // No token manipulations after declarations with flags.
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS                            1 << 10
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_FLAGS                            BIT(10)
 
 // No all permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL                  1 << 11
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_ALL                  BIT(11)
 
 // No datum type permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE           1 << 12
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_DATUM_TYPE           BIT(12)
 
 // No tx sender permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER            1 << 13
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_SENDER            BIT(13)
 
 // No tx receiver permissions lists manipulations after declarations
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER          1 << 14
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_STATIC_PERMISSIONS_TX_RECEIVER          BIT(14)
 
 //  Maximal flag
-#define DAP_CHAIN_DATUM_TOKEN_FLAG_MAX                                     1 << 15
+#define DAP_CHAIN_DATUM_TOKEN_FLAG_MAX                                     BIT(15)
 
 #define DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED                               0xffff
 
diff --git a/modules/global-db/dap_chain_global_db.c b/modules/global-db/dap_chain_global_db.c
index a76fcfa16ec5f26f31bbba78729a20758155147f..800954aab7d72eabc75c7a7e466b47d8f4ccdadb 100644
--- a/modules/global-db/dap_chain_global_db.c
+++ b/modules/global-db/dap_chain_global_db.c
@@ -582,7 +582,7 @@ void dap_global_db_obj_track_history(dap_store_obj_t *a_store_data)
  */
 bool dap_chain_global_db_gr_set(const char *a_key, const void *a_value, size_t a_value_len, const char *a_group)
 {
-dap_store_obj_t store_data = {0};
+    dap_store_obj_t store_data = {0};
 
     store_data.key = a_key;
     store_data.value_len = (a_value_len == (size_t) -1) ? dap_strlen(a_value) : a_value_len;
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 3f254cca9385b37bbe5ba23cdce7c11ad79fdfa9..81d3b6a7e45da32aabfbc7c7be6d85eb05b0cf48 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -1529,7 +1529,7 @@ bool s_chain_net_reload_ledger_cache_once(dap_chain_net_t *l_net)
         return false;
     }
     // create file, if it not presented. If file exists, ledger cache operation is stopped
-    char *l_cache_file = dap_strdup_printf( "%s/%s.cache", l_cache_dir, "4CFB3928-1A9A-467D-BB5E-3FDB35014E8A");
+    char *l_cache_file = dap_strdup_printf( "%s/%s.cache", l_cache_dir, "5B0FEEF6-B0D5-48A9-BFA2-32E8B294366D");
     if (dap_file_simple_test(l_cache_file)) {
         return false;
     }
@@ -2977,15 +2977,14 @@ void dap_chain_net_dump_datum(dap_string_t *a_str_out, dap_chain_datum_t *a_datu
                 case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
                 case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE:{
                     dap_string_append_printf(a_str_out, "type: SIMPLE\n");
-                    dap_string_append_printf(a_str_out, "sign_total: %hu\n", l_token->header_private.signs_total );
-                    dap_string_append_printf(a_str_out, "sign_valid: %hu\n", l_token->header_private.signs_valid );
+                    dap_string_append_printf(a_str_out, "sign_total: %hu\n", l_token->header_simple.signs_total );
+                    dap_string_append_printf(a_str_out, "sign_valid: %hu\n", l_token->header_simple.signs_valid );
                     if ( dap_chain_datum_token_is_old(l_token->type) )
-                        dap_string_append_printf(a_str_out, "total_supply: %"DAP_UINT64_FORMAT_U"\n", l_token->header_private.total_supply );
+                        dap_string_append_printf(a_str_out, "total_supply: %"DAP_UINT64_FORMAT_U"\n", l_token->header_simple.total_supply );
                     else
                         dap_string_append_printf(a_str_out, "total_supply: %s\n",
-                                                dap_chain_balance_print(l_token->header_private.total_supply_256));
+                                                dap_chain_balance_print(l_token->header_simple.total_supply_256));
                 }break;
-                case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
                 case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE:{
                     dap_string_append_printf(a_str_out,"type: PRIVATE_UPDATE\n");
                     dap_tsd_t * l_tsd = dap_chain_datum_token_tsd_get(l_token, l_token_size);
@@ -3104,9 +3103,8 @@ void dap_chain_net_dump_datum(dap_string_t *a_str_out, dap_chain_datum_t *a_datu
                         }
                     }
                 }break;
-                case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
                 case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL:{
-                    dap_string_append_printf(a_str_out,"type: PRIVATE_DECL\n");
+                    dap_string_append_printf(a_str_out,"type: PRIVATE\n");
                     dap_string_append_printf(a_str_out,"flags: ");
                     dap_chain_datum_token_flags_dump(a_str_out, l_token->header_private_decl.flags);
                     dap_tsd_t * l_tsd_first = dap_chain_datum_token_tsd_get(l_token, l_token_size);
@@ -3171,6 +3169,72 @@ void dap_chain_net_dump_datum(dap_string_t *a_str_out, dap_chain_datum_t *a_datu
                     size_t l_certs_field_size = l_token_size - sizeof(*l_token) - l_token->header_private_decl.tsd_total_size;
                     dap_chain_datum_token_certs_dump(a_str_out, l_token->data_n_tsd, l_certs_field_size);
                 }break;
+                case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL:{
+                    dap_string_append_printf(a_str_out,"type: NATIVE\n");
+                    dap_string_append_printf(a_str_out,"flags: ");
+                    dap_chain_datum_token_flags_dump(a_str_out, l_token->header_native_decl.flags);
+                    dap_tsd_t * l_tsd_first = dap_chain_datum_token_tsd_get(l_token, l_token_size);
+                    if (l_tsd_first == NULL)
+                        dap_string_append_printf(a_str_out,"<CORRUPTED TSD SECTION>\n");
+                    else{
+                        size_t l_offset = 0;
+                        size_t l_offset_max = l_token->header_native_decl.tsd_total_size;
+                        while( l_offset< l_offset_max){
+                            dap_tsd_t * l_tsd = (void*)l_tsd_first + l_offset;
+                            if ( (l_tsd->size+l_offset) >l_offset_max){
+                                log_it(L_WARNING, "<CORRUPTED TSD> too big size %u when left maximum %zu",
+                                       l_tsd->size, l_offset_max - l_offset);
+                                return;
+                            }
+                            switch( l_tsd->type){
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: // 256
+                                    dap_string_append_printf(a_str_out,"total_supply: %s\n",
+                                                            dap_chain_balance_print(
+                                                                    dap_tsd_get_scalar(l_tsd, uint256_t)));
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY: // 128
+                                        dap_string_append_printf(a_str_out,"total_supply: %s\n",
+                                                            dap_chain_balance_print(GET_256_FROM_128(
+                                                                                        dap_tsd_get_scalar(l_tsd, uint128_t))));
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID :
+                                    dap_string_append_printf(a_str_out,"total_signs_valid: %u\n",
+                                                             dap_tsd_get_scalar(l_tsd, uint16_t) );
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_ADD  :
+                                    dap_string_append_printf(a_str_out,"datum_type_allowed: %s\n",
+                                                             dap_tsd_get_string_const(l_tsd) );
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_ADD  :
+                                    dap_string_append_printf(a_str_out,"datum_type_blocked: %s\n",
+                                                             dap_tsd_get_string_const(l_tsd) );
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD:
+                                    dap_string_append_printf(a_str_out,"tx_sender_allowed: %s\n",
+                                                             dap_tsd_get_string_const(l_tsd) );
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD:
+                                    dap_string_append_printf(a_str_out,"tx_sender_blocked: %s\n",
+                                                             dap_tsd_get_string_const(l_tsd) );
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
+                                    dap_string_append_printf(a_str_out,"tx_receiver_allowed: %s\n",
+                                                             dap_tsd_get_string_const(l_tsd) );
+                                break;
+                                case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD:
+                                    dap_string_append_printf(a_str_out, "tx_receiver_blocked: %s\n",
+                                                             dap_tsd_get_string_const(l_tsd) );
+                                break;
+                                default: dap_string_append_printf(a_str_out, "<0x%04hX>: <size %u>\n", l_tsd->type, l_tsd->size);
+                            }
+                            l_offset += dap_tsd_size(l_tsd);
+
+                        }
+                    }
+
+                    size_t l_certs_field_size = l_token_size - sizeof(*l_token) - l_token->header_native_decl.tsd_total_size;
+                    dap_chain_datum_token_certs_dump(a_str_out, l_token->data_n_tsd, l_certs_field_size);
+                }break;
                 case DAP_CHAIN_DATUM_TX:{
                     dap_chain_datum_tx_t * l_tx =(dap_chain_datum_tx_t *) a_datum->data;
                     char buf[50];
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index dea4554097b2f8f23202d7eff097b8b40b988be0..805f3d60846a798d642b3277dd1215e61e9f00e3 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -213,7 +213,7 @@ static dap_chain_datum_token_t * s_sign_cert_in_cycle(dap_cert_t ** l_certs, dap
     for(size_t i = 0; i < l_certs_count; i++) 
     {
         dap_sign_t * l_sign = dap_cert_sign(l_certs[i],  l_datum_token, 
-           sizeof(l_datum_token->header_private), 0);
+           sizeof(l_datum_token->header_simple), 0);
 
         if (l_sign)
         {
@@ -959,7 +959,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
         // handler of command 'node add'
         int l_ret = node_info_add_with_reply(l_net, l_node_info, alias_str, l_cell_str, a_ipv4_str, a_ipv6_str,
                 a_str_reply);
-        DAP_DELETE(l_node_info);
+        //DAP_DELETE(l_node_info); ticket 5804
         return l_ret;
         //break;
 
@@ -1707,21 +1707,14 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
             dap_chain_node_cli_set_reply_text(str_reply, "Wallet name option <-w>  not defined");
             return -1;
         }
-
-        //
-        // Check if wallet name has only digits and English letters
-        //
-
-        size_t is_str = dap_isstralnum(l_wallet_name);
-
-        if (!is_str)
-        {
+        // Check if wallet name has only digits and English letter
+        if (!dap_isstralnum(l_wallet_name)){
             dap_chain_node_cli_set_reply_text(str_reply, "Wallet name must contains digits and aplhabetical symbols");
             return -1;
         }
 
         // check wallet existence
-        if(!l_is_force) {
+        if(!l_is_force){
             dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_name, c_wallets_path);
             if(l_wallet) {
                 dap_chain_node_cli_set_reply_text(str_reply, "Wallet already exists");
@@ -1798,7 +1791,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
                         dap_chain_addr_t *l_addr = l_net? dap_chain_wallet_get_addr(l_wallet, l_net->pub.id) : NULL;
                         char *l_addr_str = dap_chain_addr_to_str(l_addr);
                         dap_string_append_printf(l_string_ret, "\nwallet: %s\n", l_wallet->name);
-                        if ( l_addr_str){
+                        if (l_addr_str){
                             dap_string_append_printf(l_string_ret, "addr: %s\n", (l_addr_str) ? l_addr_str : "-");
                             DAP_DELETE(l_addr_str);
                         }
@@ -2040,7 +2033,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
             if(l_datum->header.type_id == DAP_CHAIN_DATUM_TOKEN_DECL) {
                 dap_chain_datum_token_t * l_datum_token = (dap_chain_datum_token_t *) l_datum->data;
                 size_t l_datum_token_size = l_datum->header.data_size;
-                if (l_datum_token->header_private.signs_valid == l_datum_token->header_private.signs_total) {
+                if (l_datum_token->header_simple.signs_valid == l_datum_token->header_simple.signs_total) {
                     dap_chain_node_cli_set_reply_text(a_str_reply,
                             "Datum %s with datum token has all signs on board. Can't add anything to it", l_datum_hash_out_str);
                     DAP_DELETE(l_datum);
@@ -2051,7 +2044,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
                 size_t l_signs_size = 0, i = 1;
                 do {
                     dap_sign_t *l_sign = (dap_sign_t *)l_datum_token->data_n_tsd + l_signs_size;
-                    if( dap_sign_verify(l_sign, l_datum_token, sizeof(l_datum_token->header_private)) != 1) {
+                    if( dap_sign_verify(l_sign, l_datum_token, sizeof(l_datum_token->header_simple)) != 1) {
                         log_it(L_WARNING, "Wrong signature %zu for datum_token with key %s in mempool!", i, l_datum_hash_out_str);
                         dap_chain_node_cli_set_reply_text(a_str_reply,
                                 "Datum %s with datum token has wrong signature %zu, break process and exit",
@@ -2063,11 +2056,11 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
                         log_it(L_DEBUG,"Sign %zu passed", i);
                     }
                     l_signs_size += dap_sign_get_size(l_sign);
-                } while (i++ <= l_datum_token->header_private.signs_valid);
+                } while (i++ <= l_datum_token->header_simple.signs_valid);
                 log_it(L_DEBUG, "Datum %s with token declaration: %hu signatures are verified well (sign_size = %zu)",
-                                 l_datum_hash_out_str, l_datum_token->header_private.signs_valid, l_signs_size);
+                                 l_datum_hash_out_str, l_datum_token->header_simple.signs_valid, l_signs_size);
 
-                if (l_datum_token->header_private.signs_total >= l_datum_token->header_private.signs_valid + l_certs_count) {
+                if (l_datum_token->header_simple.signs_total >= l_datum_token->header_simple.signs_valid + l_certs_count) {
                     // Copy TSD sections to new location
                     size_t l_tsd_size = l_datum_token_size - l_signs_size;
                     uint8_t *l_token_tsd = DAP_NEW_SIZE(uint8_t, l_tsd_size);
@@ -2077,7 +2070,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
                         // Add signs to token
                         dap_sign_t * l_sign = dap_sign_create(l_certs[i]->enc_key,
                                 l_datum_token,
-                                sizeof(l_datum_token->header_private), 0);
+                                sizeof(l_datum_token->header_simple), 0);
                         size_t l_sign_size = dap_sign_get_size(l_sign);
 
                         l_signs_size += l_sign_size;
@@ -2158,7 +2151,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
                 } else {
                     dap_chain_node_cli_set_reply_text(a_str_reply,
                             "Error! Not enought place for new signature (%hu is left when we need %hu signatures)",
-                            l_datum_token->header_private.signs_total - l_datum_token->header_private.signs_valid, l_certs_count);
+                            l_datum_token->header_simple.signs_total - l_datum_token->header_simple.signs_valid, l_certs_count);
                     return -6;
                 }
             } else {
@@ -2745,7 +2738,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
     }
 
     dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE, l_datum_token_update,
-            sizeof(l_datum_token_update->header_private) + l_datum_data_offset);
+            sizeof(l_datum_token_update->header_simple) + l_datum_data_offset);
     size_t l_datum_size = dap_chain_datum_size(l_datum);
 
     // Calc datum's hash
@@ -2860,7 +2853,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
     uint16_t l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
 
     const char * l_hash_out_type = NULL;
-    dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
+    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-H", &l_hash_out_type);
     if(!l_hash_out_type)
         l_hash_out_type = "hex";
     if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
@@ -2878,7 +2871,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
         }
     }
     // Token ticker
-    l_arg_index=dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_ticker);
+    l_arg_index=dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-token", &l_ticker);
     // Check for ticker
     if(!l_ticker) {
         dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'token'");
@@ -2886,7 +2879,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
     }
 
     // Token type
-    l_arg_index=dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-type", &l_type_str);
+    l_arg_index=dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-type", &l_type_str);
 
     if (l_type_str) {
         if (strcmp( l_type_str, "private") == 0){
@@ -2895,6 +2888,8 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
             l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
         }else if (strcmp( l_type_str, "public_simple") == 0){
             l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC; // 256
+        }else if (strcmp( l_type_str, "native") == 0){
+            l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL; // 256
         }
     }
 
@@ -2902,43 +2897,92 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
     size_t l_datum_data_offset = 0;
     uint32_t l_sign_counter = 0;
 
+    // Certificates thats will be used to sign currend datum token
+    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-certs", &l_certs_str);
+    // Signs number thats own emissioncan't find
+    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-signs_total", &l_signs_total_str);
+    // Signs minimum number thats need to authorize the emission
+    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-signs_emission", &l_signs_emission_str);
+
+    //DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL uses decimals parameter
+    if (l_type != DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL){
+        // Total supply value
+        dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-total_supply", &l_total_supply_str);
+
+        if(!l_total_supply_str) {
+            dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-total_supply'");
+            return -3;
+        } else {
+            l_total_supply = dap_chain_balance_scan((char *)l_total_supply_str);
+            if (IS_ZERO_256(l_total_supply)){
+                dap_chain_node_cli_set_reply_text(a_str_reply,
+                        "token_create requires parameter '-total_supply' to be unsigned integer value that fits in 8 bytes");
+                return -4;
+            }
+        }
+    }
+
+    if (l_type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL){
+         dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-decimals", &l_total_supply_str);
+
+        if(!l_total_supply_str) {
+            dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-decimals'");
+            return -3;
+        } else {
+            l_total_supply = dap_chain_balance_scan((char *)l_total_supply_str);
+            if (IS_ZERO_256(l_total_supply)){
+                dap_chain_node_cli_set_reply_text(a_str_reply,
+                        "token_create requires parameter '-decimals' to be unsigned integer value that fits in 8 bytes");
+                return -4;
+            }
+        }
+    }
+   
+    // Signs emission
+    if(!l_signs_emission_str){
+        dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-signs_emission'");
+        return -5;
+    } else {
+        char * l_tmp = NULL;
+        if((l_signs_emission = (uint16_t) strtol(l_signs_emission_str, &l_tmp, 10)) == 0){
+            dap_chain_node_cli_set_reply_text(a_str_reply,
+                    "token_create requires parameter 'signs_emission' to be unsigned integer value that fits in 2 bytes");
+            return -6;
+        }
+    }
+    // Signs total
+    if(!l_signs_total_str){
+        dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'signs_total'");
+        return -7;
+    } else {
+        char * l_tmp = NULL;
+        if((l_signs_total = (uint16_t) strtol(l_signs_total_str, &l_tmp, 10)) == 0){
+            dap_chain_node_cli_set_reply_text(a_str_reply,
+                    "token_create requires parameter 'signs_total' to be unsigned integer value that fits in 2 bytes");
+            return -8;
+        }
+    }
+    // Check certs list
+    if(!l_certs_str) {
+        dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'certs'");
+        return -9;
+    }
+    // Load certs lists
+    dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
+    if(!l_certs_count){
+        dap_chain_node_cli_set_reply_text(a_str_reply,
+                "token_decl command requres at least one valid certificate to sign the basic transaction of emission");
+        return -10;
+    }
+
     switch(l_type){
         case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: { // 256
             dap_list_t *l_tsd_list = NULL;
             size_t l_tsd_total_size = 0;
             uint16_t l_flags = 0;
             char ** l_str_flags = NULL;
-            dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-signs_total", &l_signs_total_str);
-            // Certificates thats will be used to sign currend datum token
-            dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-certs", &l_certs_str);
-
-            // Check certs list
-            if(!l_certs_str) {
-                dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'certs'");
-                return -9;
-            }
-
-            // Load certs lists
-            dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
-            if(!l_certs_count) {
-                dap_chain_node_cli_set_reply_text(a_str_reply,
-                        "token_decl command requres at least one valid certificate to sign the basic transaction of emission");
-                return -10;
-            }
-
-                        // Signs total
-            if(!l_signs_total_str) {
-                dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'signs_total'");
-                return -7;
-            } else {
-                char * l_tmp = NULL;
-                if((l_signs_total = (uint16_t) strtol(l_signs_total_str, &l_tmp, 10)) == 0) {
-                    dap_chain_node_cli_set_reply_text(a_str_reply,
-                            "token_create requires parameter 'signs_total' to be unsigned integer value that fits in 2 bytes");
-                    return -8;
-                }
-            }
             l_arg_index++;
+
             while (l_arg_index<a_argc-1){
                 char * l_arg_param=  a_argv[l_arg_index+1];
                 if ( strcmp(a_argv[l_arg_index],"-flags" )==0){   // Flags
@@ -2985,12 +3029,27 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
                     l_tsd_total_size+= dap_tsd_size( l_tsd);
                 }else if ( strcmp( a_argv[l_arg_index],"-tx_receiver_allowed" )==0){
                     const char *a_tx_receiver_allowed_base58 = NULL;
-                    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &a_tx_receiver_allowed_base58);
-                    dap_chain_addr_t *addr_to = dap_chain_addr_from_str(a_tx_receiver_allowed_base58);
-                    dap_tsd_t * l_tsd = dap_tsd_create(DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD, addr_to, sizeof(dap_chain_addr_t));
-                    l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
-                    //dap_tsd_t * l_tsd = dap_tsd_create_string(DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD, a_tx_receiver_allowed_base58);
-                    l_tsd_total_size+= dap_tsd_size( l_tsd);
+                    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &a_tx_receiver_allowed_base58);        
+                    char ** l_str_wallet_addr = NULL;
+                    l_str_wallet_addr = dap_strsplit( a_tx_receiver_allowed_base58,",",0xffff );
+
+                    if (!l_str_wallet_addr){
+                       log_it(L_DEBUG,"Error in wallet addresses array parsing in tx_receiver_allowed parameter");
+                       return -10;
+                    }
+
+                    while (l_str_wallet_addr && *l_str_wallet_addr){
+                        log_it(L_DEBUG,"Processing wallet address: %s", *l_str_wallet_addr);
+                        dap_chain_addr_t *addr_to = dap_chain_addr_from_str(*l_str_wallet_addr);
+                        if (addr_to){
+                            dap_tsd_t * l_tsd = dap_tsd_create(DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD, addr_to, sizeof(dap_chain_addr_t));
+                            l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                            l_tsd_total_size+= dap_tsd_size( l_tsd);
+                        } else{
+                            log_it(L_DEBUG,"Error in wallet address parsing");
+                        }
+                        l_str_wallet_addr++;
+                     }
                 }else if ( strcmp( a_argv[l_arg_index],"-tx_receiver_blocked" )==0){
                     dap_tsd_t * l_tsd = dap_tsd_create_string(
                                                             DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD, l_arg_param);
@@ -3006,26 +3065,30 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
                                                             DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD, l_arg_param);
                     l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
                     l_tsd_total_size+= dap_tsd_size( l_tsd);
-                }else {
-                    dap_chain_node_cli_set_reply_text(a_str_reply, "Unknown param \"%s\"",a_argv[l_arg_index]);
-                    return -20;
+                // }else {
+                //     dap_chain_node_cli_set_reply_text(a_str_reply, "Unknown param \"%s\"",a_argv[l_arg_index]);
+                //     return -20;
                 }
                 l_arg_index+=2;
             }
 
-
             // If we have more certs than we need signs - use only first part of the list
             if(l_certs_count > l_signs_total)
                 l_certs_count = l_signs_total;
 
-            log_it(L_DEBUG,"Prepeared TSD sections on %zd total size", l_tsd_total_size);
+            log_it(L_DEBUG,"Prepeared TSD sections for private token on %zd total size", l_tsd_total_size);
             // Create new datum token
-            l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t)+l_tsd_total_size ) ;
+            l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t)) ;
             
             l_datum_token->type = l_type; //DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL;
             
             dap_snprintf(l_datum_token->ticker, sizeof(l_datum_token->ticker), "%s", l_ticker);
-            l_datum_token->header_private_decl.flags = l_flags;
+            l_datum_token->header_private_decl.flags = l_flags;   
+            l_datum_token->header_private_decl.total_supply_256 = l_total_supply;
+            l_datum_token->header_private_decl.current_supply_256 = l_total_supply;
+            l_datum_token->header_private_decl.signs_total = l_signs_total;
+            l_datum_token->header_private_decl.signs_valid = l_signs_emission;
+
             log_it(L_DEBUG,"Token declaration '%s' initialized", l_datum_token->ticker);
 
             // Sign header with all certificates in the list and add signs to the end of ticker declaration
@@ -3057,15 +3120,14 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
                                dap_tsd_get_string_const(l_tsd) );
                     break;
                     case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD:
-                        log_it(L_DEBUG,"== TX_RECEIVER_ALLOWED_ADD: binary data");
+                        log_it(L_DEBUG,"== TX_SENDER_ALLOWED_ADD: binary data");
                     break;
                     case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD:
                         log_it(L_DEBUG,"== TX_SENDER_BLOCKED_ADD: %s",
                                 dap_tsd_get_string_const(l_tsd) );
                     break;
                     case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
-                        log_it(L_DEBUG,"== TX_RECEIVER_ALLOWED_ADD: %s",
-                                dap_tsd_get_string_const(l_tsd) );
+                        log_it(L_DEBUG,"== TX_SENDER_ALLOWED_ADD: binary data");
                     break;
                     case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD:
                         log_it(L_DEBUG,"== TX_RECEIVER_BLOCKED_ADD: %s",
@@ -3074,98 +3136,188 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
                     default: log_it(L_DEBUG, "== 0x%04X: binary data %u size ",l_tsd->type, l_tsd->size );
                 }
                 size_t l_tsd_size = dap_tsd_size( l_tsd);
-                //add realloc
+                //add realloc: size of token header + sizeof signed data s_sign_cert_in_cycle + n * l_tsd_size
                 l_datum_token = DAP_REALLOC(l_datum_token, sizeof(dap_chain_datum_token_t) + l_datum_data_offset + l_tsd_size);
                 memcpy(l_datum_token->data_n_tsd + l_datum_data_offset, l_tsd, l_tsd_size);
                 l_datum_token->header_private_decl.tsd_total_size += l_tsd_size;
                 l_datum_data_offset += l_tsd_size;
             }
-
-
         }break;
         case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: { // 256
-            // Total supply value
-            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-total_supply", &l_total_supply_str);
-
+            // If we have more certs than we need signs - use only first part of the list
+            if(l_certs_count > l_signs_total)
+                l_certs_count = l_signs_total;
 
-            // Certificates thats will be used to sign currend datum token
-            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-certs", &l_certs_str);
+            // Create new datum token
+            l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t));
+            l_datum_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
+            dap_snprintf(l_datum_token->ticker, sizeof(l_datum_token->ticker), "%s", l_ticker);
+            l_datum_token->header_simple.total_supply_256 = l_total_supply;
+            l_datum_token->header_simple.current_supply_256 = l_total_supply;
+            l_datum_token->header_simple.signs_total = l_signs_total;
+            l_datum_token->header_simple.signs_valid = l_signs_emission;
 
-            // Signs number thats own emissioncan't find
-            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-signs_total", &l_signs_total_str);
+            // Sign header with all certificates in the list and add signs to the end of ticker declaration
+            // Important:
 
-            // Signs minimum number thats need to authorize the emission
-            dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-signs_emission", &l_signs_emission_str);
+             l_datum_token = s_sign_cert_in_cycle(l_certs, l_datum_token, l_certs_count, &l_datum_data_offset, &l_sign_counter);
 
-            if(!l_total_supply_str) {
-                dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-total_supply'");
-                return -3;
-            } else {
-                l_total_supply = dap_chain_balance_scan((char *)l_total_supply_str);
-                if ( IS_ZERO_256(l_total_supply) ) {
-                    dap_chain_node_cli_set_reply_text(a_str_reply,
-                            "token_create requires parameter '-total_supply' to be unsigned integer value that fits in 8 bytes");
-                    return -4;
-                }
-            }
+        }break;
+        case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL: {
+            dap_list_t *l_tsd_list = NULL;
+            size_t l_tsd_total_size = 0;
+            uint16_t l_flags = 0;
+            char ** l_str_flags = NULL;
+            l_arg_index = 0;
 
-            // Signs emission
-            if(!l_signs_emission_str) {
-                dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter '-signs_emission'");
-                return -5;
-            } else {
-                char * l_tmp = NULL;
-                if((l_signs_emission = (uint16_t) strtol(l_signs_emission_str, &l_tmp, 10)) == 0) {
-                    dap_chain_node_cli_set_reply_text(a_str_reply,
-                            "token_create requires parameter 'signs_emission' to be unsigned integer value that fits in 2 bytes");
-                    return -6;
-                }
-            }
+            //load -decimals parameter to l_total_supply_str
+            dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-decimals", &l_total_supply_str);
 
-            // Signs total
-            if(!l_signs_total_str) {
-                dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'signs_total'");
-                return -7;
-            } else {
-                char * l_tmp = NULL;
-                if((l_signs_total = (uint16_t) strtol(l_signs_total_str, &l_tmp, 10)) == 0) {
-                    dap_chain_node_cli_set_reply_text(a_str_reply,
-                            "token_create requires parameter 'signs_total' to be unsigned integer value that fits in 2 bytes");
-                    return -8;
-                }
-            }
+            while (l_arg_index<a_argc-1){
+                char * l_arg_param=  a_argv[l_arg_index+1];
+                if ( strcmp(a_argv[l_arg_index],"-flags" )==0){   // Flags
+                     l_str_flags = dap_strsplit( l_arg_param,",",0xffff );
+                     while (l_str_flags && *l_str_flags){
+                         uint16_t l_flag = dap_chain_datum_token_flag_from_str(*l_str_flags);
+                         if ( l_flag == DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED ){
+                             dap_chain_node_cli_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
+                             return -20;
+                         }
+                         l_flags |= l_flag; // if we have multiple flags
+                         l_str_flags++;
+                     }
+                }else if ( strcmp( a_argv[l_arg_index],"-signs" )==0){
+                    dap_cert_parse_str_list(l_arg_param, &l_certs, &l_certs_count);
+                    if(!l_certs_count) {
+                        dap_chain_node_cli_set_reply_text(a_str_reply,
+                                "token_decl command requres at least one valid certificate to sign the basic transaction of emission");
+                        return -10;
+                    }
+                }else if ( strcmp( a_argv[l_arg_index],"-datum_type_allowed" )==0){
+                    dap_tsd_t * l_tsd = dap_tsd_create_string(
+                                                            DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_ADD, l_arg_param);
+                    l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                    l_tsd_total_size+= dap_tsd_size( l_tsd);
+                }else if ( strcmp( a_argv[l_arg_index],"-datum_type_blocked" )==0){
+                    dap_tsd_t * l_tsd = dap_tsd_create_string(
+                                                            DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_BLOCKED_ADD, l_arg_param);
+                    l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                    l_tsd_total_size+= dap_tsd_size( l_tsd);
+                }else if ( strcmp( a_argv[l_arg_index],"-tx_receiver_allowed" )==0){
+                    const char *a_tx_receiver_allowed_base58 = NULL;
+                    dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &a_tx_receiver_allowed_base58);        
+                    char ** l_str_wallet_addr = NULL;
+                    l_str_wallet_addr = dap_strsplit( a_tx_receiver_allowed_base58,",",0xffff );
 
-            // Check certs list
-            if(!l_certs_str) {
-                dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'certs'");
-                return -9;
-            }
+                    if (!l_str_wallet_addr){
+                       log_it(L_DEBUG,"Error in wallet addresses array parsing in tx_receiver_allowed parameter");
+                       return -10;
+                    }
 
-            // Load certs lists
-            dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
-            if(!l_certs_count) {
-                dap_chain_node_cli_set_reply_text(a_str_reply,
-                        "token_decl command requres at least one valid certificate to sign the basic transaction of emission");
-                return -10;
+                    while (l_str_wallet_addr && *l_str_wallet_addr){
+                        log_it(L_DEBUG,"Processing wallet address: %s", *l_str_wallet_addr);
+                        dap_chain_addr_t *addr_to = dap_chain_addr_from_str(*l_str_wallet_addr);
+                        if (addr_to){
+                            dap_tsd_t * l_tsd = dap_tsd_create(DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD, addr_to, sizeof(dap_chain_addr_t));
+                            l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                            l_tsd_total_size+= dap_tsd_size( l_tsd);
+                        } else{
+                            log_it(L_DEBUG,"Error in wallet address parsing");
+                        }
+                        l_str_wallet_addr++;
+                     }
+                }else if ( strcmp( a_argv[l_arg_index],"-tx_receiver_blocked" )==0){
+                    dap_tsd_t * l_tsd = dap_tsd_create_string(
+                                                            DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD, l_arg_param);
+                    l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                    l_tsd_total_size+= dap_tsd_size( l_tsd);
+                }else if ( strcmp( a_argv[l_arg_index],"-tx_sender_allowed" )==0){
+                    dap_tsd_t * l_tsd = dap_tsd_create_string(
+                                                            DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD, l_arg_param);
+                    l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                    l_tsd_total_size+= dap_tsd_size( l_tsd);
+                }else if ( strcmp( a_argv[l_arg_index],"-tx_sender_blocked" )==0){
+                    dap_tsd_t * l_tsd = dap_tsd_create_string(
+                                                            DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD, l_arg_param);
+                    l_tsd_list = dap_list_append( l_tsd_list, l_tsd);
+                    l_tsd_total_size+= dap_tsd_size( l_tsd);
+                // }else {
+                //     dap_chain_node_cli_set_reply_text(a_str_reply, "Unknown param \"%s\"",a_argv[l_arg_index]);
+                //     return -20;
+                }
+                l_arg_index+=1;
             }
 
             // If we have more certs than we need signs - use only first part of the list
             if(l_certs_count > l_signs_total)
                 l_certs_count = l_signs_total;
 
+            log_it(L_DEBUG,"Prepeared TSD sections for native token on %zd total size", l_tsd_total_size);
             // Create new datum token
-            l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t));
-            l_datum_token->type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE; // 256
+            l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t, sizeof(dap_chain_datum_token_t)) ;
+            
+            l_datum_token->type = l_type; //DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL;
+            
             dap_snprintf(l_datum_token->ticker, sizeof(l_datum_token->ticker), "%s", l_ticker);
-            l_datum_token->header_private.total_supply_256 = l_total_supply;
-            l_datum_token->header_private.signs_total = l_signs_total;
-            l_datum_token->header_private.signs_valid = l_signs_emission;
+            l_datum_token->header_native_decl.flags = l_flags;   
+            l_datum_token->header_native_decl.total_supply_256 = l_total_supply;
+            l_datum_token->header_native_decl.current_supply_256 = l_total_supply;
+            l_datum_token->header_native_decl.signs_total = l_signs_total;
+            l_datum_token->header_native_decl.signs_valid = l_signs_emission;
+
+            log_it(L_DEBUG,"Token declaration '%s' initialized", l_datum_token->ticker);
 
             // Sign header with all certificates in the list and add signs to the end of ticker declaration
             // Important:
 
-             l_datum_token = s_sign_cert_in_cycle(l_certs, l_datum_token, l_certs_count, &l_datum_data_offset, &l_sign_counter);
+            l_datum_token = s_sign_cert_in_cycle(l_certs, l_datum_token, l_certs_count, &l_datum_data_offset, &l_sign_counter);
 
+            // Add TSD sections in the end
+            for ( dap_list_t* l_iter=dap_list_first(l_tsd_list); l_iter; l_iter=l_iter->next){
+                dap_tsd_t * l_tsd = (dap_tsd_t *) l_iter->data;
+                if (l_tsd == NULL){
+                    log_it(L_ERROR, "NULL tsd in list!");
+                    continue;
+                }
+                switch (l_tsd->type){
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SUPPLY_256: { // 256
+                        char *l_balance;
+                        l_balance = dap_chain_balance_print(dap_tsd_get_scalar(l_tsd, uint256_t));
+                        log_it(L_DEBUG,"== TOTAL_SUPPLY: %s", l_balance);
+                        DAP_DELETE(l_balance);
+                    }
+                    break;
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TOTAL_SIGNS_VALID:
+                        log_it(L_DEBUG,"== TOTAL_SIGNS_VALID: %u",
+                                dap_tsd_get_scalar(l_tsd,uint16_t) );
+                    break;
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_DATUM_TYPE_ALLOWED_ADD:
+                        log_it(L_DEBUG,"== DATUM_TYPE_ALLOWED_ADD: %s",
+                               dap_tsd_get_string_const(l_tsd) );
+                    break;
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_ALLOWED_ADD:
+                        log_it(L_DEBUG,"== TX_SENDER_ALLOWED_ADD: binary data");
+                    break;
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_SENDER_BLOCKED_ADD:
+                        log_it(L_DEBUG,"== TX_SENDER_BLOCKED_ADD: %s",
+                                dap_tsd_get_string_const(l_tsd) );
+                    break;
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_ALLOWED_ADD:
+                        log_it(L_DEBUG,"== TX_SENDER_ALLOWED_ADD: binary data");
+                    break;
+                    case DAP_CHAIN_DATUM_TOKEN_TSD_TYPE_TX_RECEIVER_BLOCKED_ADD:
+                        log_it(L_DEBUG,"== TX_RECEIVER_BLOCKED_ADD: %s",
+                                dap_tsd_get_string_const(l_tsd) );
+                    break;
+                    default: log_it(L_DEBUG, "== 0x%04X: binary data %u size ",l_tsd->type, l_tsd->size );
+                }
+                size_t l_tsd_size = dap_tsd_size( l_tsd);
+                //add realloc: size of token header + sizeof signed data s_sign_cert_in_cycle + n * l_tsd_size
+                l_datum_token = DAP_REALLOC(l_datum_token, sizeof(dap_chain_datum_token_t) + l_datum_data_offset + l_tsd_size);
+                memcpy(l_datum_token->data_n_tsd + l_datum_data_offset, l_tsd, l_tsd_size);
+                l_datum_token->header_native_decl.tsd_total_size += l_tsd_size;
+                l_datum_data_offset += l_tsd_size;
+            }
         }break;
         default:
             dap_chain_node_cli_set_reply_text(a_str_reply,
@@ -3173,13 +3325,9 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
             return -8;
     }
 
-    //
     // We skip datum creation opeartion, if count of signed certificates in s_sign_cert_in_cycle is 0.
     // Usually it happen, when certificate in token_decl or token_update command doesn't contain private data or broken
-    //
-
-    if (l_sign_counter == 0)
-    {
+    if (l_sign_counter == 0){
         dap_chain_node_cli_set_reply_text(a_str_reply,
                     "Token declaration failed. Successful count of certificate signing is 0");
             return -9;
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index e0b93b3f27c28e516e275d27619c0fb71bba1760..141b3cdf86f84a1f28dbf51c4ad4236c77b42026 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -899,27 +899,34 @@ static char* dap_db_history_token_list(dap_chain_t * a_chain, const char *a_toke
                         // Simple private token decl
                         case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
                            dap_string_append_printf(l_str_out, "  total_supply: %s(%s), signs: valid/total %02d/%02d \n",
-                                    dap_chain_balance_to_coins(l_token->header_private.total_supply_256),
-                                    dap_chain_balance_print(l_token->header_private.total_supply_256),
-                                    l_token->header_private.signs_valid, l_token->header_private.signs_total);
+                                    dap_chain_balance_to_coins(l_token->header_simple.total_supply_256),
+                                    dap_chain_balance_print(l_token->header_simple.total_supply_256),
+                                    l_token->header_simple.signs_valid, l_token->header_simple.signs_total);
                             break;
                         case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
                             dap_string_append_printf(l_str_out, "  total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
-                                    dap_chain_datoshi_to_coins(l_token->header_private.total_supply),
-                                    l_token->header_private.total_supply,
-                                    l_token->header_private.signs_valid, l_token->header_private.signs_total);
+                                    dap_chain_datoshi_to_coins(l_token->header_simple.total_supply),
+                                    l_token->header_simple.total_supply,
+                                    l_token->header_simple.signs_valid, l_token->header_simple.signs_total);
                             break;
                         case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
-                        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
                             dap_string_append_printf(l_str_out, "  tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
                                     l_token->header_private_decl.tsd_total_size,
                                     l_token->header_private_decl.flags);
                             break;
+                        case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL: // 256
+                            dap_string_append_printf(l_str_out, "  tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+                                    l_token->header_native_decl.tsd_total_size,
+                                    l_token->header_native_decl.flags);
+                            break;
                         case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_UPDATE: // 256
-                        case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
                             dap_string_append_printf(l_str_out, "  tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
                                     l_token->header_private_update.tsd_total_size);
                             break;
+                        case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE: // 256
+                            dap_string_append_printf(l_str_out, "  tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
+                                    l_token->header_native_update.tsd_total_size);
+                            break;
                         case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: { // 256
                             char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);
                             char * l_balance = dap_chain_balance_to_coins(l_token->header_public.total_supply_256);
@@ -1036,23 +1043,23 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
                         // Simple private token decl
                             case DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE: // 256
                                 dap_string_append_printf(l_str_out, "  256bit total_supply: %s(%s), signs: valid/total %02d/%02d \n",
-                                        dap_chain_balance_to_coins(l_token->header_private.total_supply_256),
-                                        dap_chain_balance_print(l_token->header_private.total_supply_256),
-                                        l_token->header_private.signs_valid, l_token->header_private.signs_total);
+                                        dap_chain_balance_to_coins(l_token->header_simple.total_supply_256),
+                                        dap_chain_balance_print(l_token->header_simple.total_supply_256),
+                                        l_token->header_simple.signs_valid, l_token->header_simple.signs_total);
                                 break;
                             case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_SIMPLE:
                                 dap_string_append_printf(l_str_out, "  total_supply: %.0Lf(%"DAP_UINT64_FORMAT_U"), signs: valid/total %02d/%02d \n",
-                                        dap_chain_datoshi_to_coins(l_token->header_private.total_supply),
-                                        l_token->header_private.total_supply,
-                                        l_token->header_private.signs_valid, l_token->header_private.signs_total);
+                                        dap_chain_datoshi_to_coins(l_token->header_simple.total_supply),
+                                        l_token->header_simple.total_supply,
+                                        l_token->header_simple.signs_valid, l_token->header_simple.signs_total);
                                 break;
                             case DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL: // 256
                                 dap_string_append_printf(l_str_out, "256bit  tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
                                         l_token->header_private_decl.tsd_total_size,
                                         l_token->header_private_decl.flags);
                                 break;
-                            case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_DECL:
-                                dap_string_append_printf(l_str_out, "  tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
+                            case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL: // 256
+                                dap_string_append_printf(l_str_out, "256bit  tsd_total_size: %"DAP_UINT64_FORMAT_U", flags: 0x%x \n",
                                         l_token->header_private_decl.tsd_total_size,
                                         l_token->header_private_decl.flags);
                                 break;
@@ -1060,9 +1067,9 @@ static char* dap_db_history_filter(dap_chain_t * a_chain, dap_ledger_t *a_ledger
                                 dap_string_append_printf(l_str_out, "256bit  tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
                                         l_token->header_private_update.tsd_total_size);
                                 break;
-                            case DAP_CHAIN_DATUM_TOKEN_TYPE_OLD_PRIVATE_UPDATE:
-                                dap_string_append_printf(l_str_out, "  tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
-                                        l_token->header_private_update.tsd_total_size);
+                            case DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_UPDATE: // 256
+                                dap_string_append_printf(l_str_out, "256bit  tsd_total_size: %"DAP_UINT64_FORMAT_U"\n",
+                                        l_token->header_native_update.tsd_total_size);
                                 break;
                             case DAP_CHAIN_DATUM_TOKEN_TYPE_PUBLIC: { // 256
                                 char *l_addr = dap_chain_addr_to_str(&l_token->header_public.premine_address);