diff --git a/modules/mempool/dap_chain_mempool.c b/modules/mempool/dap_chain_mempool.c
index 562dbc76647670e61e86811e890870384605f6aa..c438ca2e17e297014a600981de0665e688c8fea6 100644
--- a/modules/mempool/dap_chain_mempool.c
+++ b/modules/mempool/dap_chain_mempool.c
@@ -828,19 +828,19 @@ char *dap_chain_mempool_tx_create_cond(dap_chain_net_t *a_net,
 
 char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast_t *a_emission_hash,
                                        dap_chain_id_t a_emission_chain_id, uint256_t a_emission_value, const char *a_ticker,
-                                       dap_enc_key_t *a_key_from, dap_chain_addr_t *a_addr_to, dap_cert_t **a_certs, size_t a_certs_count,
+                                       dap_chain_addr_t *a_addr_to, dap_enc_key_t *a_private_key,
                                        const char *a_hash_out_type, uint256_t a_value_fee)
 {
     uint256_t l_net_fee = {};
     uint256_t l_total_fee = a_value_fee;
     uint256_t l_value_need = a_emission_value;
     uint256_t l_value_transfer = {};
-    dap_chain_addr_t l_addr_fee = {};
-    dap_chain_addr_t* l_addr_from = NULL;
+    dap_chain_addr_t l_addr_to_fee = {};
+    dap_chain_addr_t l_addr_from_fee = {};
     dap_list_t *l_list_used_out;
     const char *l_native_ticker = dap_chain_net_by_id(a_chain->net_id)->pub.native_ticker;
     bool not_native = dap_strcmp(a_ticker, l_native_ticker);
-    bool l_net_fee_used = dap_chain_net_tx_get_fee(a_chain->net_id, &l_net_fee, &l_addr_fee);
+    bool l_net_fee_used = dap_chain_net_tx_get_fee(a_chain->net_id, &l_net_fee, &l_addr_to_fee);
     if(l_net_fee_used)
         SUM_256_256(l_total_fee,l_net_fee,&l_total_fee);
 
@@ -857,19 +857,16 @@ char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast
     }
     if (not_native)
     {
-        l_addr_from = DAP_NEW_Z(dap_chain_addr_t);
-        dap_chain_addr_fill_from_key(l_addr_from, a_key_from, a_chain->net_id);
-        if(!l_addr_from){
+        if (dap_chain_addr_fill_from_key(&l_addr_from_fee, a_private_key, a_chain->net_id) != 0 ) {
             log_it(L_WARNING,"Can't fill address from transfer");
             dap_chain_datum_tx_delete(l_tx);
             return NULL;
         }
             // list of transaction with 'out' items
         l_list_used_out = dap_chain_ledger_get_list_tx_outs_with_val(a_chain->ledger, l_native_ticker,
-                                                                                 l_addr_from, l_total_fee, &l_value_transfer);
+                                                                     &l_addr_from_fee, l_total_fee, &l_value_transfer);
         if (!l_list_used_out) {
             log_it(L_WARNING,"Not enough funds to transfer");
-            DAP_DEL_Z(l_addr_from);
             dap_chain_datum_tx_delete(l_tx);
             return NULL;
         }
@@ -882,21 +879,18 @@ char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast
          //add out
         uint256_t l_value_back = l_value_transfer; // how much datoshi add to 'out' items
          // Network fee
-        if (!dap_chain_datum_tx_add_out_ext_item(&l_tx, &l_addr_fee, l_net_fee, l_native_ticker)){
+        if (!dap_chain_datum_tx_add_out_ext_item(&l_tx, &l_addr_to_fee, l_net_fee, l_native_ticker)){
             dap_chain_datum_tx_delete(l_tx);
-            DAP_DEL_Z(l_addr_from);
             return NULL;
         }
         SUBTRACT_256_256(l_value_back, l_net_fee, &l_value_back);
         if (!IS_ZERO_256(a_value_fee))
             SUBTRACT_256_256(l_value_back, a_value_fee, &l_value_back);
         // coin back
-        if (!dap_chain_datum_tx_add_out_ext_item(&l_tx, l_addr_from, l_value_back, l_native_ticker)){
+        if (!dap_chain_datum_tx_add_out_ext_item(&l_tx, &l_addr_from_fee, l_value_back, l_native_ticker)){
             dap_chain_datum_tx_delete(l_tx);
-            DAP_DEL_Z(l_addr_from);
             return NULL;
         }
-        DAP_DEL_Z(l_addr_from);
 
         if (!dap_chain_datum_tx_add_out_ext_item(&l_tx, a_addr_to, l_value_need, a_ticker)){
             dap_chain_datum_tx_delete(l_tx);
@@ -907,7 +901,7 @@ char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast
             SUBTRACT_256_256(l_value_need, a_value_fee, &l_value_need);
         if(l_net_fee_used){
             SUBTRACT_256_256(l_value_need, l_net_fee, &l_value_need);
-            if (!dap_chain_datum_tx_add_out_item(&l_tx, &l_addr_fee, l_net_fee)){
+            if (!dap_chain_datum_tx_add_out_item(&l_tx, &l_addr_to_fee, l_net_fee)){
                 dap_chain_datum_tx_delete(l_tx);
                 return NULL;
             }
@@ -924,29 +918,9 @@ char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast
         }
     }
     //sign item
-    if (not_native)
-    {
-        if(a_key_from)
-            if(dap_chain_datum_tx_add_sign_item(&l_tx, a_key_from) < 0) {
-                log_it(L_WARNING, "No private key for sign");
-                return NULL;
-            }
-    }
-    else{
-        if (a_certs) {
-            for(size_t i = 0; i < a_certs_count; i++) {
-                if(dap_chain_datum_tx_add_sign_item(&l_tx, a_certs[i]->enc_key) < 0) {
-                    log_it(L_WARNING, "No private key for certificate '%s'", a_certs[i]->name);
-                    return NULL;
-                }
-            }
-        }
-        else
-            if(a_key_from)
-                if(dap_chain_datum_tx_add_sign_item(&l_tx, a_key_from) < 0) {
-                    log_it(L_WARNING, "No private key for sign");
-                    return NULL;
-                }
+    if(dap_chain_datum_tx_add_sign_item(&l_tx, a_private_key) < 0) {
+        log_it(L_WARNING, "No private key for sign");
+        return NULL;
     }
 
     size_t l_tx_size = dap_chain_datum_tx_get_size(l_tx);
diff --git a/modules/mempool/include/dap_chain_mempool.h b/modules/mempool/include/dap_chain_mempool.h
index f14bdce4ebae2ee3249b48147e618ab0b787a0e9..97a3042c191e27cf21c386cb799deadf115e269e 100644
--- a/modules/mempool/include/dap_chain_mempool.h
+++ b/modules/mempool/include/dap_chain_mempool.h
@@ -83,9 +83,23 @@ int dap_chain_mempool_tx_create_massive(dap_chain_t * a_chain, dap_enc_key_t *a_
         const char a_token_ticker[DAP_CHAIN_TICKER_SIZE_MAX],
         uint256_t a_value, uint256_t a_value_fee, size_t a_tx_num);
 
+/**
+ * @brief dap_chain_mempool_base_tx_create
+ * @param a_chain
+ * @param a_emission_hash
+ * @param a_emission_chain_id
+ * @param a_emission_value
+ * @param a_ticker
+ * @param a_addr_to
+ * @param a_private_key For a basic transaction not in a native token, use the key obtained from the wallet. For the
+ * basic transaction in the native token, use the key obtained from the certificate.
+ * @param a_hash_out_type
+ * @param a_value_fee
+ * @return
+ */
 char *dap_chain_mempool_base_tx_create(dap_chain_t *a_chain, dap_chain_hash_fast_t *a_emission_hash,
                                        dap_chain_id_t a_emission_chain_id, uint256_t a_emission_value, const char *a_ticker,
-                                       dap_enc_key_t *a_key_from, dap_chain_addr_t *a_addr_to, dap_cert_t **a_certs, size_t a_certs_count,
+                                       dap_chain_addr_t *a_addr_to, dap_enc_key_t *a_private_key,
                                        const char *a_hash_out_type, uint256_t a_value_fee);
 
 dap_chain_datum_token_emission_t *dap_chain_mempool_emission_get(dap_chain_t *a_chain, const char *a_emission_hash_str);
diff --git a/modules/net/dap_chain_node_cli.c b/modules/net/dap_chain_node_cli.c
index 314bd2dcedd970e0103ee1c936d7da709ba74af7..cd8edd3ad001012d941598cfccfc3a22b9b8cb99 100644
--- a/modules/net/dap_chain_node_cli.c
+++ b/modules/net/dap_chain_node_cli.c
@@ -273,7 +273,7 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
     // Transaction commands
     dap_cli_server_cmd_add ("tx_create", com_tx_create, "Make transaction",
             "tx_create -net <net_name> -chain <chain_name> -value <value> -token <token_ticker> -to_addr <addr>"
-            "{-from_wallet <wallet_name> | -from_emission <emission_hash> {-certs <cert list> | -wallet_fee <wallet_name>}} -fee <value>\n");
+            "{-from_wallet <wallet_name> | -from_emission <emission_hash> {-cert <cert_name> | -wallet_fee <wallet_name>}} -fee <value>\n");
     dap_cli_server_cmd_add ("tx_create_json", com_tx_create_json, "Make transaction",
                 "tx_create_json -net <net_name> -chain <chain_name> -json <json_file_path>\n" );
     dap_cli_server_cmd_add ("tx_cond_create", com_tx_cond_create, "Make cond transaction",
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index a8e1cb47ec395a0294dd945b0959ba2623b09ba7..a62447ea254df379062ec2efacf50079ea6c1df8 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -5112,9 +5112,9 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
     const char * l_emission_chain_name = NULL;
     const char * l_tx_num_str = NULL;
     const char *l_emission_hash_str = NULL;
-    const char *l_certs_str = NULL;
-    dap_cert_t **l_certs = NULL;
-    size_t l_certs_count = 0;
+    const char *l_cert_str = NULL;
+    dap_cert_t *l_cert = NULL;
+    dap_enc_key_t *l_priv_key = NULL;
     dap_chain_hash_fast_t l_emission_hash = {};
     size_t l_tx_num = 0;
     dap_chain_wallet_t * l_wallet_fee = NULL;
@@ -5139,7 +5139,7 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
     dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_name);
     dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-chain", &l_chain_name);
     dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-tx_num", &l_tx_num_str);
-    dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
+    dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-cert", &l_cert_str);
 
     if(l_tx_num_str)
         l_tx_num = strtoul(l_tx_num_str, NULL, 10);
@@ -5221,6 +5221,7 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
                     dap_cli_server_cmd_set_reply_text(a_str_reply, "wallet %s does not exist", l_wallet_fee_name);
                     return -12;
                 }
+                l_priv_key = dap_chain_wallet_get_key(l_wallet_fee, 0);
             } else {
                 dap_cli_server_cmd_set_reply_text(a_str_reply, "To create a basic transaction with a "
                                                                "non-native ticker, you must specify the '-wallet_fee' "
@@ -5229,16 +5230,17 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
                 return -11;
             }
         } else {
-            if (l_certs_str) {
-                dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
-                if (!l_certs_count) {
+            if (l_cert_str) {
+                l_cert = dap_cert_find_by_name(l_cert_str);
+                if (!l_cert) {
                     dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                                      "tx_create requires at least one valid certificate to sign the basic transaction of emission");
+                                                      "tx_create requires one valid certificate to sign the basic transaction of emission");
                     return -5;
                 }
+                l_priv_key = l_cert->enc_key;
             } else {
                 dap_cli_server_cmd_set_reply_text(a_str_reply,
-                                                  "tx_create requires parameter '-certs' for create base tx for emission in native token");
+                                                  "tx_create requires parameter '-cert' for create base tx for emission in native token");
                 return -10;
             }
         }
@@ -5268,15 +5270,14 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
     if (l_emission_hash_str) {
         bool not_native = dap_strcmp(l_token_ticker, l_net->pub.native_ticker);
         char *l_tx_hash_str = NULL;
-        if (not_native) {
-            l_tx_hash_str = dap_chain_mempool_base_tx_create(l_chain, &l_emission_hash, l_emission_chain->id,
-                                             l_value, l_token_ticker,dap_chain_wallet_get_key(l_wallet_fee, 0), l_addr_to, NULL,
-                                             0, l_hash_out_type,l_value_fee);
-        } else {
-            l_tx_hash_str = dap_chain_mempool_base_tx_create(l_chain, &l_emission_hash, l_emission_chain->id,
-                                             l_value, l_token_ticker,NULL, l_addr_to, l_certs,
-                                             l_certs_count, l_hash_out_type,l_value_fee);
-        }
+        if (!l_priv_key) {
+            dap_string_append_printf(l_string_ret, "No private key defined for creating the underlying "
+                                                   "transaction no '-wallet_fee' or ' -cert' parameter specified.");
+            res = -10;
+        }
+        l_tx_hash_str = dap_chain_mempool_base_tx_create(l_chain, &l_emission_hash, l_emission_chain->id,
+                                                         l_value, l_token_ticker, l_addr_to, l_priv_key,
+                                                         l_hash_out_type,l_value_fee);
         if (l_tx_hash_str) {
             dap_string_append_printf(l_string_ret, "\nDatum %s with 256bit TX is placed in datum pool\n", l_tx_hash_str);
             DAP_DELETE(l_tx_hash_str);
@@ -5288,6 +5289,7 @@ int com_tx_create(int a_argc, char **a_argv, char **a_str_reply)
         dap_string_free(l_string_ret, true);
         DAP_DELETE(l_addr_to);
         dap_chain_wallet_close(l_wallet_fee);
+        DAP_DEL_Z(l_cert);
         return res;        
     }