diff --git a/net/adc_net_concepts.h b/net/adc_net_concepts.h
index 010ee1d..2028856 100644
--- a/net/adc_net_concepts.h
+++ b/net/adc_net_concepts.h
@@ -75,13 +75,13 @@ using adc_common_duration_t = adc_duration_common_type_t<std::chrono::nanosecond
         auto send(const R&, const std::chrono::duration<Rep, Period>&)
 
         template<adc::traits::adc_output_char_range R, typename Rep, typename Period>
-        R received(const std::chrono::duration<Rep, Period>&)
+        R receive(const std::chrono::duration<Rep, Period>&)
 
     }
 */
 template <typename SRVT,
-          typename SMSGT = std::string_view,     // sending message type
-          typename RMSGT = std::string,          // receiving message type
+          typename SMSGT = std::vector<char>,    // sending message type
+          typename RMSGT = std::vector<char>,    // receiving message type
           typename DURT = adc_common_duration_t  // time duration type
           >
 concept adc_netservice_c =
diff --git a/net/adc_netproto.h b/net/adc_netproto.h
index 0af88ba..7d491f0 100644
--- a/net/adc_netproto.h
+++ b/net/adc_netproto.h
@@ -108,7 +108,7 @@ struct AdcStopSeqSessionProto {
     template <traits::adc_input_char_range R>
     auto fromProto(const R& r)
     {
-        auto N = std::distance(r.begin(), r.end());
+        size_t N = std::distance(r.begin(), r.end());
 
         if (N < STOP_SEQ_SIZE) {  // one must ensure for input range size correctness
             // return std::span<std::ranges::range_value_t<R>>();
diff --git a/net/asio/adc_netservice_asio.h b/net/asio/adc_netservice_asio.h
index b6101cc..160eedf 100644
--- a/net/asio/adc_netservice_asio.h
+++ b/net/asio/adc_netservice_asio.h
@@ -31,6 +31,7 @@
 
 #include "../../common/adc_traits.h"
 #include "../adc_net_concepts.h"
+#include "../adc_netproto.h"
 
 
 namespace adc::impl
@@ -72,33 +73,19 @@ concept adc_asio_special_comp_token =
     adc_asio_is_future<T> || adc_asio_is_awaitable<T> || std::same_as<std::remove_cvref_t<T>, asio::deferred_t>;
 
 
-// template <typename T>
-// static constexpr bool adc_is_asio_special_comp_token = std::is_same_v<std::remove_cvref_t<T>, asio::use_future_t<>>
-// ||
-//                                                        std::is_same_v<std::remove_cvref_t<T>, asio::deferred_t> ||
-//                                                        std::is_same_v<std::remove_cvref_t<T>,
-//                                                        asio::use_awaitable_t<>>;
-
-struct adc_asio_async_call_ctx_t {
-};
-
-// template <typename T>
-// concept adc_completion_token_c = traits::adc_is_callable<T> || std::same_as<T, adc_asio_async_call_ctx_t> ||
-//                                  std::same_as<T, asio::deferred_t> || adc_asio_is_future<T> ||
-//                                  asio::completion_token_for;
+// class adc_asio_async_call_ctx_t
+// {
+// };
 
 
-// template <typename T, typename SignatureT>
+// template <typename T, typename SignatureT = void>
 // concept adc_completion_token_c =
-//     std::same_as<T, adc_asio_async_call_ctx_t> || asio::completion_token_for<T, SignatureT>;
+//     std::same_as<T, adc_asio_async_call_ctx_t> ||
+//     (traits::adc_is_callable<T> &&
+//      std::conditional_t<std::same_as<SignatureT, void>,
+//                         std::true_type,
+//                         std::bool_constant<asio::completion_token_for<T, SignatureT>>>::value);
 
-template <typename T, typename SignatureT = void>
-concept adc_completion_token_c =
-    std::same_as<T, adc_asio_async_call_ctx_t> ||
-    (traits::adc_is_callable<T> &&
-     std::conditional_t<std::same_as<SignatureT, void>,
-                        std::true_type,
-                        std::bool_constant<asio::completion_token_for<T, SignatureT>>>::value);
 
 
 template <adc_asio_transport_proto_c TRANSPORT_PROTOT,
@@ -116,47 +103,46 @@ public:
                            std::nullptr_t,  // there is no acceptor
                            typename TRANSPORT_PROTOT::acceptor>;
 
-    struct asio_async_ctx_t {
-        bool use_future = false;
-        std::function<void(std::error_code)> accept_comp_token;
-        std::function<void(std::error_code)> connect_comp_token;
-        std::function<void(std::error_code)> send_comp_token;
-        std::function<void(std::error_code, RMSGT)> receive_comp_token;
-    };
+    typedef std::function<void(std::error_code)> async_accept_callback_t;
+    typedef std::function<void(std::error_code)> async_connect_callback_t;
+    typedef std::function<void(std::error_code)> async_send_callback_t;
+    typedef std::function<void(std::error_code, RMSGT)> async_receive_callback_t;
 
-    class contx_t
+
+    // to satisfy 'adc_netservice_c' concept
+    class async_call_ctx_t
     {
         std::function<void(std::error_code)> _errc_comp_token;
         std::function<void(std::error_code, RMSGT)> _errc_msg_comp_token;
 
     public:
-        contx_t() = default;
+        async_call_ctx_t() = default;
 
-        contx_t(contx_t&) = default;
-        contx_t(contx_t&&) = default;
-        contx_t(const contx_t&) = default;
+        async_call_ctx_t(async_call_ctx_t&) = default;
+        async_call_ctx_t(async_call_ctx_t&&) = default;
+        async_call_ctx_t(const async_call_ctx_t&) = default;
 
         template <asio::completion_token_for<void(std::error_code)> TokenT>
-        contx_t(TokenT&& token)
+        async_call_ctx_t(TokenT&& token)
         {
             _errc_comp_token = std::forward<TokenT>(token);
         }
 
         template <asio::completion_token_for<void(std::error_code, RMSGT)> TokenT>
-        contx_t(TokenT&& token)
+        async_call_ctx_t(TokenT&& token)
         {
             _errc_msg_comp_token = std::forward<TokenT>(token);
         }
 
         template <asio::completion_token_for<void(std::error_code)> TokenT>
-        contx_t& operator=(TokenT&& token)
+        async_call_ctx_t& operator=(TokenT&& token)
         {
             _errc_comp_token = std::forward<TokenT>(token);
             return *this;
         }
 
         template <asio::completion_token_for<void(std::error_code, RMSGT)> TokenT>
-        contx_t& operator=(TokenT&& token)
+        async_call_ctx_t& operator=(TokenT&& token)
         {
             _errc_msg_comp_token = std::forward<TokenT>(token);
             return *this;
@@ -185,8 +171,6 @@ public:
         }
     };
 
-    // to satisfy 'adc_netservice_c' concept
-    using async_call_ctx_t = adc_asio_async_call_ctx_t;
 
     static constexpr std::chrono::duration DEFAULT_ACCEPT_TIMEOUT = std::chrono::seconds::max();
     static constexpr std::chrono::duration DEFAULT_CONNECT_TIMEOUT = std::chrono::seconds(10);
@@ -303,7 +287,7 @@ public:
 
 
     template <traits::adc_input_char_range MessageT,
-              adc_completion_token_c<void(std::error_code ec)> TokenT,
+              asio::completion_token_for<void(std::error_code ec)> TokenT,
               traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_SEND_TIMEOUT)>
     auto asyncSend(const MessageT& msg, TokenT&& token, const TimeoutT& timeout = DEFAULT_SEND_TIMEOUT)
     {
@@ -346,13 +330,13 @@ public:
     }
 
 
-    template <adc_completion_token_c TokenT, traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_RECEIVE_TIMEOUT)>
+    template <typename TokenT, traits::adc_time_duration_c TimeoutT = decltype(DEFAULT_RECEIVE_TIMEOUT)>
     auto asyncReceive(TokenT&& token, const TimeoutT& timeout = DEFAULT_RECEIVE_TIMEOUT)
     {
-        static_assert(!std::is_same_v<TokenT, async_call_ctx_t>, "'async_call_ctx_t'-TYPE MUST NOT BE USED!");
+        constexpr auto is_async_ctx_t = std::same_as<std::remove_cvref_t<TokenT>, async_call_ctx_t>;
 
         // check completion token signature and deduce message type
-        if constexpr (!adc_asio_special_comp_token<TokenT>) {
+        if constexpr (!adc_asio_special_comp_token<TokenT> && !is_async_ctx_t) {
             static_assert(traits::adc_func_traits<TokenT>::arity == 2, "INVALID COMPLETION TOKEN SIGNATURE!");
             static_assert(std::is_same_v<std::remove_cvref_t<traits::adc_func_arg1_t<TokenT>>, std::error_code>,
                           "INVALID COMPLETION TOKEN SIGNATURE!");
@@ -362,7 +346,7 @@ public:
         }
 
         using msg_t = std::conditional_t<
-            adc_asio_special_comp_token<TokenT>, RMSGT,
+            adc_asio_special_comp_token<TokenT> || is_async_ctx_t, RMSGT,
             std::remove_cvref_t<std::tuple_element_t<1, typename traits::adc_func_traits<TokenT>::args_t>>>;
 
         // auto s_res = std::make_shared<std::invoke_result_t<decltype(this->template search<RMSGT>), RMSGT>>();
@@ -639,4 +623,10 @@ protected:
     }
 };
 
+
+// static_assert(adc::interfaces::adc_netservice_c<AdcNetServiceASIOBase<asio::ip::tcp, adc::AdcStopSeqSessionProto<>>>,
+//               "");
+
+static_assert(adc::interfaces::adc_netsession_proto_c<adc::AdcStopSeqSessionProto<>>, "");
+
 }  // namespace adc::impl