diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4f3c734fd4ec33209a13ce9923b23d362e5ad93c..b186283706cc1e4a4d543cfc38f368b0f1a44e82 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -93,6 +93,7 @@ if (BUILD_DAP_SDK_TESTS)
     set(DAPSDK_MODULES "app-cli crypto io network-core network-server network-link_manager network-client global-db test-framework")
     set(SPHINCSPLUS_FLEX ON)
     message("[+] Enable dap_sdk_tests")
+    add_definitions("-DDAP_SDK_TESTS")
 endif ()
 
 if (DAPSDK_MODULES MATCHES "test-framework")
diff --git a/core/include/dap_tsd.h b/core/include/dap_tsd.h
index 6c4b126c0e7229f57b9817b5ef003fa2848defbe..fac776aaef7e41a15e2d6a67e7701acc27a896ef 100644
--- a/core/include/dap_tsd.h
+++ b/core/include/dap_tsd.h
@@ -58,3 +58,33 @@ dap_list_t *dap_tsd_find_all(byte_t *a_data, size_t a_data_size, uint16_t a_type
                 ? (dap_tsd_t*)l_pos : NULL);                                                                                \
             l_pos += iter_size                                                                                              \
         )
+/**
+ * @brief calculate total tsd size from tsd list
+ * @param a_tsd_list
+ * @return total size
+ */
+DAP_STATIC_INLINE size_t dap_tsd_calc_list_size(dap_list_t *a_tsd_list)
+{
+    size_t l_ret = 0;
+    for ( dap_list_t* l_iter = dap_list_first(a_tsd_list); l_iter; l_iter = l_iter->next ) {
+        l_ret += dap_tsd_size((dap_tsd_t *) l_iter->data);
+    }
+    return l_ret;
+}
+
+/**
+ * @brief serialise data from tsd list
+ * @param a_dst - pointer to allocated memory
+ * @param a_tsd_list - list with tsd data
+ * @return filled size
+ */
+DAP_STATIC_INLINE size_t dap_tsd_fill_from_list(byte_t *a_dst, dap_list_t *a_tsd_list)
+{
+    size_t l_offset = 0;
+    for ( dap_list_t* l_iter = dap_list_first(a_tsd_list); l_iter; l_iter = l_iter->next) {
+        size_t l_tsd_size = dap_tsd_size((dap_tsd_t *) l_iter->data);
+        memcpy(a_dst + l_offset, l_iter->data, l_tsd_size);
+        l_offset += l_tsd_size;
+    }
+    return l_offset;
+}
\ No newline at end of file
diff --git a/crypto/include/dap_cert.h b/crypto/include/dap_cert.h
index 6eff50d58b3a61df6be7e7461ee3a106cea1d4c8..3f6dd5f9f1872083f958e3367be1594f363e2160 100755
--- a/crypto/include/dap_cert.h
+++ b/crypto/include/dap_cert.h
@@ -89,7 +89,12 @@ int dap_cert_get_pkey_hash(dap_cert_t *a_cert, dap_hash_fast_t *a_out_hash);
 dap_cert_t *dap_cert_find_by_name(const char *a_cert_name);
 dap_list_t *dap_cert_get_all_mem();
 
-dap_sign_t *dap_cert_sign(dap_cert_t *a_cert, const void *a_data, size_t a_data_size, uint32_t a_hash_type);
+dap_sign_t *dap_cert_sign_with_hash_type(dap_cert_t *a_cert, const void *a_data, size_t a_data_size, uint32_t a_hash_type);
+DAP_STATIC_INLINE dap_sign_t *dap_cert_sign(dap_cert_t *a_cert, const void *a_data, size_t a_data_size)
+{
+    return dap_cert_sign_with_hash_type(a_cert, a_data, a_data_size, DAP_SIGN_HASH_TYPE_DEFAULT);
+}
+
 // Sign raw data, without hashing
 int dap_cert_sign_output(dap_cert_t *a_cert, const void *a_data, size_t a_data_size, void *a_output, size_t *a_output_size);
 
diff --git a/crypto/include/dap_sign.h b/crypto/include/dap_sign.h
index d05aaa9b74d23d2fe5125ffa928117eae606473f..84dca889905380653fa1bda157eeeeb7fae50b64 100755
--- a/crypto/include/dap_sign.h
+++ b/crypto/include/dap_sign.h
@@ -135,7 +135,12 @@ static inline int dap_sign_verify_all(dap_sign_t * a_sign, const size_t a_sign_s
 const char *dap_sign_get_str_recommended_types();
 
 // Create sign of data hash with key provided algorythm of signing and hashing (independently)
-dap_sign_t * dap_sign_create(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size, uint32_t a_hash_type);
+dap_sign_t * dap_sign_create_with_hash_type(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size, uint32_t a_hash_type);
+
+DAP_STATIC_INLINE dap_sign_t *dap_sign_create(dap_enc_key_t *a_key, const void *a_data, const size_t a_data_size)
+{
+    return dap_sign_create_with_hash_type(a_key, a_data, a_data_size, DAP_SIGN_HASH_TYPE_DEFAULT);
+}
 //Create sign on raw data without hashing. Singing algorythm is key provided
 int dap_sign_create_output(dap_enc_key_t *a_key, const void * a_data, const size_t a_data_size, void * a_output, size_t *a_output_size);
 
diff --git a/crypto/src/dap_cert.c b/crypto/src/dap_cert.c
index 7c6224092208aa265b051cc923a841e716584998..790af209c60015c26fd575baefbc0112326dec14 100755
--- a/crypto/src/dap_cert.c
+++ b/crypto/src/dap_cert.c
@@ -172,19 +172,18 @@ int dap_cert_sign_output(dap_cert_t * a_cert, const void * a_data, size_t a_data
 }
 
 /**
- * @brief
- * sign data by encryption key from certificate
+ * @brief sign data by encryption key from certificate with choosed hash type
  * @param a_cert dap_cert_t * certificate object
  * @param a_data data for signing
  * @param a_data_size data size
  * @param a_hash_type data and pkey hash type
  * @return dap_sign_t*
  */
-dap_sign_t *dap_cert_sign(dap_cert_t *a_cert, const void *a_data, size_t a_data_size, uint32_t a_hash_type)
+dap_sign_t *dap_cert_sign_with_hash_type(dap_cert_t *a_cert, const void *a_data, size_t a_data_size, uint32_t a_hash_type)
 {
     dap_return_val_if_fail(a_cert && a_cert->enc_key && a_cert->enc_key->priv_key_data &&
                            a_cert->enc_key->priv_key_data_size && a_data && a_data_size, NULL);
-    dap_sign_t *l_ret = dap_sign_create(a_cert->enc_key, a_data, a_data_size, a_hash_type);
+    dap_sign_t *l_ret = dap_sign_create_with_hash_type(a_cert->enc_key, a_data, a_data_size, a_hash_type);
 
     if (l_ret)
         log_it(L_INFO, "Sign sizes: %d %d", l_ret->header.sign_size, l_ret->header.sign_pkey_size);
@@ -209,7 +208,7 @@ int dap_cert_add_cert_sign(dap_cert_t *a_cert, dap_cert_t *a_cert_signer)
             log_it(L_CRITICAL, "%s", c_error_memory_alloc);
             return -1;
         }
-        l_sign_item->sign = dap_cert_sign(a_cert_signer,a_cert->enc_key->pub_key_data,a_cert->enc_key->pub_key_data_size, DAP_SIGN_HASH_TYPE_DEFAULT);
+        l_sign_item->sign = dap_cert_sign(a_cert_signer,a_cert->enc_key->pub_key_data,a_cert->enc_key->pub_key_data_size);
         DL_APPEND ( PVT(a_cert)->signs, l_sign_item );
         return 0;
     } else {
diff --git a/crypto/src/dap_enc_multisign.c b/crypto/src/dap_enc_multisign.c
index 34bc02b78e8e9454563db650d1532c5e517497e9..5f7b7cf17ab3171b4a70163fe7489a6573372248 100755
--- a/crypto/src/dap_enc_multisign.c
+++ b/crypto/src/dap_enc_multisign.c
@@ -336,7 +336,7 @@ int dap_enc_sig_multisign_get_sign(dap_enc_key_t *a_key, const void *a_msg_in, c
             return -4;
         }
         int l_num = l_sign->key_seq[i];
-        dap_sign_t *l_dap_sign_step = dap_sign_create(l_params->keys[l_num], &l_data_hash, sizeof(dap_chain_hash_fast_t), DAP_SIGN_HASH_TYPE_DEFAULT);
+        dap_sign_t *l_dap_sign_step = dap_sign_create(l_params->keys[l_num], &l_data_hash, sizeof(dap_chain_hash_fast_t));
         if (!l_dap_sign_step) {
             log_it (L_ERROR, "Can't create multi-signature step signature");
             DAP_DEL_MULTY(l_sign->key_hashes, l_sign->key_seq, l_sign->meta, l_sign->sign_data);
diff --git a/crypto/src/dap_sign.c b/crypto/src/dap_sign.c
index 4dd8a3978e1135700002bc7bd81938792a7902cd..9ef5af7bd74ff3a053556b371f19acaad04cf519 100755
--- a/crypto/src/dap_sign.c
+++ b/crypto/src/dap_sign.c
@@ -242,15 +242,14 @@ int dap_sign_create_output(dap_enc_key_t *a_key, const void * a_data, const size
 }
 
 /**
- * @brief sign data with specified key
- * 
+ * @brief sign data with specified key with choosed hash type
  * @param a_key dap_enc_key_t key object
  * @param a_data const void * buffer with data
  * @param a_data_size const size_t buffer size
  * @param a_hash_type data and pkey hash type
  * @return dap_sign_t* 
  */
-dap_sign_t *dap_sign_create(dap_enc_key_t *a_key, const void * a_data,
+dap_sign_t *dap_sign_create_with_hash_type(dap_enc_key_t *a_key, const void * a_data,
         const size_t a_data_size, uint32_t a_hash_type)
 {
     dap_return_val_if_fail(a_key && a_key->priv_key_data && a_key->priv_key_data_size, NULL);
diff --git a/crypto/test/crypto/dap_enc_benchmark_test.c b/crypto/test/crypto/dap_enc_benchmark_test.c
index c1488a3efb69d8a1d50d142dfcf0f2eaab2a2247..e70c2623f1329d8ff430aebbd3e3376e3164977b 100644
--- a/crypto/test/crypto/dap_enc_benchmark_test.c
+++ b/crypto/test/crypto/dap_enc_benchmark_test.c
@@ -183,10 +183,10 @@ static void s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, i
         
         dap_chain_hash_fast_t l_hash = {};
         if (key->type == DAP_ENC_KEY_TYPE_SIG_ECDSA)
-            l_signs[i] = dap_sign_create(key, l_source[i], l_source_size[i], l_hash_type);
+            l_signs[i] = dap_sign_create_with_hash_type(key, l_source[i], l_source_size[i], l_hash_type);
         else {
             dap_hash_fast(l_source[i], l_source_size[i], &l_hash);
-            l_signs[i] = dap_sign_create(key, &l_hash, sizeof(l_hash), l_hash_type);
+            l_signs[i] = dap_sign_create_with_hash_type(key, &l_hash, sizeof(l_hash), l_hash_type);
         }
         if (i % 2) {
             pkey_hash_table_t *l_item = DAP_NEW_Z(pkey_hash_table_t);
diff --git a/crypto/test/crypto/dap_enc_multithread_test.c b/crypto/test/crypto/dap_enc_multithread_test.c
index 02ec5bb2f6de3b40825748b0fad92454a5726884..3ca7ea2b9b30f6df99f787608f9b09e41b8c1d2b 100644
--- a/crypto/test/crypto/dap_enc_multithread_test.c
+++ b/crypto/test/crypto/dap_enc_multithread_test.c
@@ -37,11 +37,11 @@ static int s_test_thread(dap_enc_key_type_t a_key_type, int a_times)
         
         dap_enc_key_t *key = s_enc_key_new_generate(a_key_type, NULL, 0, seed, seed_size, 0);
         if (key->type == DAP_ENC_KEY_TYPE_SIG_ECDSA)
-            l_signs[i] = dap_sign_create(key, l_source[i], l_source_size[i], DAP_SIGN_HASH_TYPE_DEFAULT);
+            l_signs[i] = dap_sign_create(key, l_source[i], l_source_size[i]);
         else {
             dap_chain_hash_fast_t l_hash;
             dap_hash_fast(l_source[i], l_source_size[i], &l_hash);
-            l_signs[i] = dap_sign_create(key, &l_hash, sizeof(l_hash), DAP_SIGN_HASH_TYPE_DEFAULT);
+            l_signs[i] = dap_sign_create(key, &l_hash, sizeof(l_hash));
         }
         
         dap_assert_PIF(l_signs[i], "Signing message and serialize");
diff --git a/global-db/dap_global_db_pkt.c b/global-db/dap_global_db_pkt.c
index 826805837642d3b9d0e8f6d39d616633f88a0342..0c2d5c0ca127a564de0bcce555a8ee40ca31df1c 100644
--- a/global-db/dap_global_db_pkt.c
+++ b/global-db/dap_global_db_pkt.c
@@ -98,7 +98,7 @@ dap_sign_t *dap_store_obj_sign(dap_store_obj_t *a_obj, dap_enc_key_t *a_key, uin
     if (a_key) {
         // Exclude CRC field from sign
         l_sign = dap_sign_create(a_key, (uint8_t *)l_pkt + sizeof(uint64_t),
-                                 dap_global_db_pkt_get_size(l_pkt) - sizeof(uint64_t), DAP_SIGN_HASH_TYPE_DEFAULT);
+                                 dap_global_db_pkt_get_size(l_pkt) - sizeof(uint64_t));
         if (!l_sign) {
             log_it(L_ERROR, "Can't sign serialized global DB object");
             DAP_DELETE(l_pkt);
diff --git a/global-db/include/dap_global_db_driver.h b/global-db/include/dap_global_db_driver.h
index 09b98ca12d8785b958f19a99ea4809d1b049d3e7..5a2e046e987c5d12d92d1573a5c469041ccce7ad 100644
--- a/global-db/include/dap_global_db_driver.h
+++ b/global-db/include/dap_global_db_driver.h
@@ -39,8 +39,13 @@
 #define DAP_GLOBAL_DB_GROUPS_COUNT_MAX      1024UL                              /* A maximum number of groups */
 #define DAP_GLOBAL_DB_KEY_SIZE_MAX          512UL                               /* A limit for the key's length in DB */
 
-#define DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT 256UL                             /* Default count of records to return with conditional read */
-#define DAP_GLOBAL_DB_COND_READ_KEYS_DEFAULT  512UL                             /* Default count of keys to return with conditional read */
+#ifndef DAP_SDK_TESTS
+    #define DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT 256UL                             /* Default count of records to return with conditional read */
+    #define DAP_GLOBAL_DB_COND_READ_KEYS_DEFAULT  512UL                             /* Default count of keys to return with conditional read */
+#else  // to more fast tests
+    #define DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT 25UL
+    #define DAP_GLOBAL_DB_COND_READ_KEYS_DEFAULT  50UL  
+#endif
 
 // Main record flags (DB saved)
 #define DAP_GLOBAL_DB_RECORD_DEL        BIT(0)                                  /* Information of record deletion (key, timestamp and sign) propagated over sync */
diff --git a/global-db/test/dap_global_db_test.c b/global-db/test/dap_global_db_test.c
index af96fdb1caf2fd70f282b9e7c8d9fc37201f8b6b..73865edb32f4826959ca50316bf4514c80e136b7 100644
--- a/global-db/test/dap_global_db_test.c
+++ b/global-db/test/dap_global_db_test.c
@@ -313,7 +313,7 @@ static void s_test_read_cond_store(size_t a_count, bool a_bench)
         dap_store_obj_free(l_objs, l_count);
     }
 
-    l_count = 99;
+    l_count = DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT / 4;
     l_driver_key = (dap_global_db_driver_hash_t){0};
     size_t l_total_count = 0;
     for (dap_store_obj_t *l_objs = dap_global_db_driver_cond_read(DAP_DB$T_GROUP, l_driver_key, &l_count, true);
@@ -328,7 +328,7 @@ static void s_test_read_cond_store(size_t a_count, bool a_bench)
     }
     dap_assert_PIF(l_total_count - dap_global_db_driver_hash_is_blank(&l_driver_key) == a_count, "Total cond read count with holes not equal total records count");
 
-    l_count = 99;
+    l_count = DAP_GLOBAL_DB_COND_READ_COUNT_DEFAULT / 4;
     l_driver_key = (dap_global_db_driver_hash_t){0};
     l_total_count = 0;
     for (dap_store_obj_t *l_objs = dap_global_db_driver_cond_read(DAP_DB$T_GROUP, l_driver_key, &l_count, false);
diff --git a/net/client/dap_client_pvt.c b/net/client/dap_client_pvt.c
index 402f62f48ad33143d4a3f0aeda453398d85834f0..419800168fbf5fbeab3b9569931ee075cfd91d40 100644
--- a/net/client/dap_client_pvt.c
+++ b/net/client/dap_client_pvt.c
@@ -339,7 +339,7 @@ int s_add_cert_sign_to_data(const dap_cert_t *a_cert, uint8_t **a_data, size_t *
 {
     dap_return_val_if_pass(!a_cert || !a_size || !a_data, 0);
 
-    dap_sign_t *l_sign = dap_sign_create(a_cert->enc_key, a_signing_data, a_signing_size, DAP_SIGN_HASH_TYPE_DEFAULT);
+    dap_sign_t *l_sign = dap_sign_create(a_cert->enc_key, a_signing_data, a_signing_size);
     dap_return_val_if_fail(l_sign, 0);    
     size_t l_sign_size = dap_sign_get_size(l_sign), l_size = *a_size;
     byte_t *l_data = DAP_REALLOC_RET_VAL_IF_FAIL(*a_data, l_size + l_sign_size, 0, l_sign);
diff --git a/net/server/enc_server/dap_enc_http.c b/net/server/enc_server/dap_enc_http.c
index 25e5a336cbaff8552ba264ea3e43c04da4fafdf4..dfa42f92a1c3edce02a66cd737e51acea2a266da 100644
--- a/net/server/enc_server/dap_enc_http.c
+++ b/net/server/enc_server/dap_enc_http.c
@@ -199,7 +199,7 @@ void enc_http_proc(struct dap_http_simple *cl_st, void * arg)
             l_enc_key_ks->node_addr = dap_stream_node_addr_from_sign(l_sign);
 
             dap_cert_t *l_node_cert = dap_cert_find_by_name(DAP_STREAM_NODE_ADDR_CERT_NAME);
-            dap_sign_t *l_node_sign = dap_sign_create(l_node_cert->enc_key,l_pkey_exchange_key->pub_key_data, l_pkey_exchange_key->pub_key_data_size, DAP_SIGN_HASH_TYPE_DEFAULT);
+            dap_sign_t *l_node_sign = dap_sign_create(l_node_cert->enc_key,l_pkey_exchange_key->pub_key_data, l_pkey_exchange_key->pub_key_data_size);
             if (!l_node_sign) {
                 dap_enc_key_delete(l_pkey_exchange_key);
                 DAP_DELETE(encrypt_msg);
diff --git a/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c b/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c
index be4e112cf34f57d77cfb0efd8a4708eacc0d3975..710d0c959df62ec24387e35848ed7c68115390eb 100644
--- a/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c
+++ b/net/server/json_rpc/rpc_core/src/dap_json_rpc_request.c
@@ -329,7 +329,7 @@ dap_json_rpc_http_request_t *dap_json_rpc_request_sign_by_cert(dap_json_rpc_requ
     if (!l_str)
         return log_it(L_ERROR, "Can't convert JSON-request to string!"), NULL;
     int l_len = strlen(l_str);
-    dap_sign_t *l_sign = dap_cert_sign(a_cert, l_str, l_len, DAP_SIGN_HASH_TYPE_DEFAULT);
+    dap_sign_t *l_sign = dap_cert_sign(a_cert, l_str, l_len);
     if (!l_sign)
         return DAP_DELETE(l_str), log_it(L_ERROR, "JSON request signing failed"), NULL;
     size_t l_sign_size = dap_sign_get_size(l_sign);