From 6ebb7f69b9bc62015bc5a6c6f51bd93e1fdb9544 Mon Sep 17 00:00:00 2001
From: Vasiliy Olekhov <vasiliy.olekhov@nil.foundation>
Date: Thu, 12 Dec 2024 11:22:46 +0200
Subject: [PATCH] wip

---
 .../core/include/nil/detail/type_traits.hpp   | 17 +++----
 .../nil/marshalling/algorithms/pack.hpp       | 50 +++++++++----------
 .../nil/marshalling/detail/pack_value.hpp     |  6 +--
 .../nil/marshalling/processing/tuple.hpp      | 34 ++++++-------
 .../num_value_multi_range_validator.hpp       |  4 +-
 .../nil/marshalling/types/array_list.hpp      |  2 +-
 .../include/nil/marshalling/types/bundle.hpp  |  2 +-
 .../marshalling/types/bundle/basic_type.hpp   |  2 +-
 8 files changed, 56 insertions(+), 61 deletions(-)

diff --git a/crypto3/libs/marshalling/core/include/nil/detail/type_traits.hpp b/crypto3/libs/marshalling/core/include/nil/detail/type_traits.hpp
index f1e7c38a9c..7c57066c01 100644
--- a/crypto3/libs/marshalling/core/include/nil/detail/type_traits.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/detail/type_traits.hpp
@@ -206,16 +206,15 @@
     };
 #endif
 
-namespace nil::crypto3 {
+namespace nil::crypto3::marshalling {
     namespace detail {
 
-//        GENERATE_HAS_MEMBER_TYPE(iterator)
-//        GENERATE_HAS_MEMBER_TYPE(const_iterator)
+        GENERATE_HAS_MEMBER_TYPE(iterator)
+        GENERATE_HAS_MEMBER_TYPE(const_iterator)
 
-//        GENERATE_HAS_MEMBER_CONST_RETURN_FUNCTION(begin, const_iterator)
-//        GENERATE_HAS_MEMBER_CONST_RETURN_FUNCTION(end, const_iterator)
+        GENERATE_HAS_MEMBER_CONST_RETURN_FUNCTION(begin, const_iterator)
+        GENERATE_HAS_MEMBER_CONST_RETURN_FUNCTION(end, const_iterator)
 
-        /*
         template<typename T>
         struct is_iterator {
             static char test(...);
@@ -228,22 +227,18 @@ namespace nil::crypto3 {
             static long test(U &&);
 
             constexpr static bool value = std::is_same<decltype(test(std::declval<T>())), long>::value;
-        };*/
+        };
 
-        /*
         template<typename Range>
         struct is_range {
             static const bool value = has_begin<Range>::value && has_end<Range>::value;
         };
-        */
 
-        /*
         template<typename Container>
         struct is_container {
             static const bool value
                 = has_const_iterator<Container>::value && has_begin<Container>::value && has_end<Container>::value;
         };
-        */
 
         /// @brief Check whether provided type is a variant of
         ///     <a href="http://en.cppreference.com/w/cpp/utility/tuple">std::tuple</a>.
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/algorithms/pack.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/algorithms/pack.hpp
index 9550ae8363..5a6f207318 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/algorithms/pack.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/algorithms/pack.hpp
@@ -60,7 +60,7 @@ namespace nil::crypto3 {
          */
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename SinglePassRange>
         typename std::enable_if<
-            nil::crypto3::detail::is_range<SinglePassRange>::value,
+            detail::is_range<SinglePassRange>::value,
             detail::range_repack_impl<TInputEndian, TOutputEndian, typename SinglePassRange::const_iterator>>::type
 
             pack(const SinglePassRange &val, status_type &status) {
@@ -69,7 +69,7 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename TInput>
-        typename std::enable_if<!nil::crypto3::detail::is_range<TInput>::value,
+        typename std::enable_if<!detail::is_range<TInput>::value,
                                 detail::value_repack_impl<TInputEndian, TOutputEndian, TInput>>::type
 
             pack(const TInput &val, status_type &status) {
@@ -93,7 +93,7 @@ namespace nil::crypto3 {
          */
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename InputIterator>
         typename std::enable_if<
-            nil::crypto3::detail::is_iterator<InputIterator>::value
+            detail::is_iterator<InputIterator>::value
                 && std::is_integral<typename std::iterator_traits<InputIterator>::value_type>::value,
             detail::range_repack_impl<TInputEndian, TOutputEndian, InputIterator>>::type
             pack(InputIterator first, InputIterator last, status_type &status) {
@@ -102,7 +102,7 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename TInput, typename TOutputIterator>
-        typename std::enable_if<!nil::crypto3::detail::is_range<TInput>::value && nil::crypto3::detail::is_iterator<TOutputIterator>::value,
+        typename std::enable_if<!detail::is_range<TInput>::value && detail::is_iterator<TOutputIterator>::value,
                                 TOutputIterator>::type
             pack(const TInput &val, TOutputIterator out, status_type &status) {
             using T = typename std::iterator_traits<TOutputIterator>::value_type;
@@ -111,8 +111,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename SinglePassRange, typename TOutputIterator>
-        typename std::enable_if<nil::crypto3::detail::is_range<SinglePassRange>::value
-                                    && nil::crypto3::detail::is_iterator<TOutputIterator>::value,
+        typename std::enable_if<detail::is_range<SinglePassRange>::value
+                                    && detail::is_iterator<TOutputIterator>::value,
                                 TOutputIterator>::type
             pack(const SinglePassRange &rng_input, TOutputIterator out, status_type &status) {
             BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
@@ -122,8 +122,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename InputIterator, typename TOutputIterator>
-        typename std::enable_if<nil::crypto3::detail::is_iterator<InputIterator>::value
-                                    && nil::crypto3::detail::is_iterator<TOutputIterator>::value,
+        typename std::enable_if<detail::is_iterator<InputIterator>::value
+                                    && detail::is_iterator<TOutputIterator>::value,
                                 TOutputIterator>::type
             pack(InputIterator first, InputIterator last, TOutputIterator out, status_type &status) {
             using T = typename std::iterator_traits<TOutputIterator>::value_type;
@@ -132,7 +132,7 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename TInput, typename SinglePassRange>
-        typename std::enable_if<!nil::crypto3::detail::is_range<TInput>::value && nil::crypto3::detail::is_range<SinglePassRange>::value
+        typename std::enable_if<!detail::is_range<TInput>::value && detail::is_range<SinglePassRange>::value
                                     && std::is_constructible<SinglePassRange,
                                                             typename std::vector<typename SinglePassRange::value_type>::const_iterator,
                                                             typename std::vector<typename SinglePassRange::value_type>::const_iterator>::value,
@@ -147,7 +147,7 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename TInput, typename SinglePassRange>
-        typename std::enable_if<!nil::crypto3::detail::is_range<TInput>::value && nil::crypto3::detail::is_range<SinglePassRange>::value
+        typename std::enable_if<!detail::is_range<TInput>::value && detail::is_range<SinglePassRange>::value
                                     && !std::is_constructible<SinglePassRange,
                                                              typename std::vector<typename SinglePassRange::value_type>::const_iterator,
                                                              typename std::vector<typename SinglePassRange::value_type>::const_iterator>::value,
@@ -161,8 +161,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename SinglePassRange1, typename SinglePassRange2>
-        typename std::enable_if<nil::crypto3::detail::is_range<SinglePassRange1>::value
-                                    && nil::crypto3::detail::is_range<SinglePassRange2>::value
+        typename std::enable_if<detail::is_range<SinglePassRange1>::value
+                                    && detail::is_range<SinglePassRange2>::value
                                     && std::is_constructible<SinglePassRange2,
                                                              typename SinglePassRange2::const_iterator,
                                                              typename SinglePassRange2::const_iterator>::value,
@@ -179,7 +179,7 @@ namespace nil::crypto3 {
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename SinglePassRange1, typename SinglePassRange2>
         typename std::enable_if<
-            nil::crypto3::detail::is_range<SinglePassRange1>::value && nil::crypto3::detail::is_range<SinglePassRange2>::value
+            detail::is_range<SinglePassRange1>::value && detail::is_range<SinglePassRange2>::value
                 && !std::is_constructible<
                     SinglePassRange2,
                     typename std::vector<typename SinglePassRange2::value_type>::const_iterator,
@@ -195,7 +195,7 @@ namespace nil::crypto3 {
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename InputIterator, typename SinglePassRange>
         typename std::enable_if<
-            nil::crypto3::detail::is_iterator<InputIterator>::value && nil::crypto3::detail::is_range<SinglePassRange>::value
+            detail::is_iterator<InputIterator>::value && detail::is_range<SinglePassRange>::value
                 && std::is_constructible<
                     SinglePassRange,
                     typename std::vector<typename SinglePassRange::value_type>::const_iterator,
@@ -211,8 +211,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename InputIterator, typename SinglePassRange>
-        typename std::enable_if<nil::crypto3::detail::is_iterator<InputIterator>::value
-                                    && nil::crypto3::detail::is_range<SinglePassRange>::value
+        typename std::enable_if<detail::is_iterator<InputIterator>::value
+                                    && detail::is_range<SinglePassRange>::value
                                     && !std::is_constructible<SinglePassRange,
                                                               typename SinglePassRange::const_iterator,
                                                               typename SinglePassRange::const_iterator>::value,
@@ -225,8 +225,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename InputIterator, typename TOutput>
-        typename std::enable_if<nil::crypto3::detail::is_iterator<InputIterator>::value
-                                    && !(nil::crypto3::detail::is_range<TOutput>::value || nil::crypto3::detail::is_array<TOutput>::value)
+        typename std::enable_if<detail::is_iterator<InputIterator>::value
+                                    && !(detail::is_range<TOutput>::value || detail::is_array<TOutput>::value)
                                     && !std::is_same<TOutput, status_type>::value,
                                 status_type>::type
             pack(InputIterator first, InputIterator last, TOutput &rng_output) {
@@ -237,8 +237,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename SinglePassRange, typename TOutput>
-        typename std::enable_if<nil::crypto3::detail::is_range<SinglePassRange>::value
-                                    && !(nil::crypto3::detail::is_range<TOutput>::value || nil::crypto3::detail::is_array<TOutput>::value)
+        typename std::enable_if<detail::is_range<SinglePassRange>::value
+                                    && !(detail::is_range<TOutput>::value || detail::is_array<TOutput>::value)
                                     && !std::is_same<TOutput, status_type>::value,
                                 status_type>::type
             pack(const SinglePassRange &rng_input, TOutput &rng_output) {
@@ -249,7 +249,7 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename TInput, typename TOutputIterator>
-        typename std::enable_if<!nil::crypto3::detail::is_range<TInput>::value && nil::crypto3::detail::is_iterator<TOutputIterator>::value,
+        typename std::enable_if<!detail::is_range<TInput>::value && detail::is_iterator<TOutputIterator>::value,
                                 status_type>::type
 
             pack(const TInput &val, TOutputIterator out) {
@@ -261,8 +261,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename SinglePassRange, typename TOutputIterator>
-        typename std::enable_if<nil::crypto3::detail::is_range<SinglePassRange>::value
-                                    && nil::crypto3::detail::is_iterator<TOutputIterator>::value,
+        typename std::enable_if<detail::is_range<SinglePassRange>::value
+                                    && detail::is_iterator<TOutputIterator>::value,
                                 status_type>::type
             pack(const SinglePassRange &rng_input, TOutputIterator out) {
             BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<const SinglePassRange>));
@@ -274,8 +274,8 @@ namespace nil::crypto3 {
         }
 
         template<typename TOutputEndian = option::big_endian, typename TInputEndian = option::big_endian, typename InputIterator, typename TOutputIterator>
-        typename std::enable_if<nil::crypto3::detail::is_iterator<InputIterator>::value
-                                    && nil::crypto3::detail::is_iterator<TOutputIterator>::value,
+        typename std::enable_if<detail::is_iterator<InputIterator>::value
+                                    && detail::is_iterator<TOutputIterator>::value,
                                 status_type>::type
             pack(InputIterator first, InputIterator last, TOutputIterator out) {
             using T = typename std::iterator_traits<TOutputIterator>::value_type;
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/detail/pack_value.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/detail/pack_value.hpp
index 12ec480770..aa6e5eabf9 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/detail/pack_value.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/detail/pack_value.hpp
@@ -92,7 +92,7 @@ namespace nil::crypto3 {
 
                 template<typename T, size_t SizeArray,
                          typename = typename std::enable_if<
-                             !nil::crypto3::detail::is_container<typename is_compatible<T>::template type<>>::value>::type>
+                             !detail::is_container<typename is_compatible<T>::template type<>>::value>::type>
                 inline operator std::array<T, SizeArray>() {
 
                     return similar_std_array_marshalling<std::array<T, SizeArray>>();
@@ -100,7 +100,7 @@ namespace nil::crypto3 {
 
                 template<typename T, size_t SizeArray,
                          typename = typename std::enable_if<
-                             !nil::crypto3::detail::is_container<typename is_compatible<T>::template type<>>::value>::type>
+                             !detail::is_container<typename is_compatible<T>::template type<>>::value>::type>
                 inline operator boost::array<T, SizeArray>() {
 
                     return similar_std_array_marshalling<boost::array<T, SizeArray>>();
@@ -131,7 +131,7 @@ namespace nil::crypto3 {
 
                 template<typename OutputRange,
                          typename = typename std::enable_if<
-                             nil::crypto3::detail::is_range<OutputRange>::value && !is_marshalling_type<OutputRange>::value
+                             detail::is_range<OutputRange>::value && !is_marshalling_type<OutputRange>::value
                              && !nil::crypto3::marshalling::is_container<typename is_compatible<
                                  typename OutputRange::value_type>::template type<>>::value>::type>
                 inline operator OutputRange() {
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/processing/tuple.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/processing/tuple.hpp
index 992278bd7b..239eeea356 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/processing/tuple.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/processing/tuple.hpp
@@ -47,7 +47,7 @@ namespace nil::crypto3 {
             template<typename TTuple>
             struct tuple_as_aligned_union {
                 /// @cond DOCUMENT_STATIC_ASSERT
-                static_assert(::nil::crypto3::detail::is_tuple<TTuple>::value, "TTuple must be std::tuple");
+                static_assert(marshalling::detail::is_tuple<TTuple>::value, "TTuple must be std::tuple");
                 /// @endcond
 
                 /// @brief Type definition is invalid for any type that is not
@@ -72,7 +72,7 @@ namespace nil::crypto3 {
             /// @brief Check whether tuple is unique, i.e. doesn't have contain types.
             template<typename TTuple>
             struct tuple_is_unique {
-                static_assert(nil::crypto3::detail::is_tuple<TTuple>::value, "TTuple must be std::tuple");
+                static_assert(marshalling::detail::is_tuple<TTuple>::value, "TTuple must be std::tuple");
 
                 /// @brief Value is set to true when tuple is discovered to be unique.
                 static const bool value = false;
@@ -81,7 +81,7 @@ namespace nil::crypto3 {
             /// @cond SKIP_DOC
             template<typename TFirst, typename... TRest>
             struct tuple_is_unique<std::tuple<TFirst, TRest...>> {
-                static const bool value = (!nil::crypto3::detail::is_in_tuple<TFirst, std::tuple<TRest...>>::value)
+                static const bool value = (!marshalling::detail::is_in_tuple<TFirst, std::tuple<TRest...>>::value)
                                           && tuple_is_unique<std::tuple<TRest...>>::value;
             };
 
@@ -103,7 +103,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TFunc>
                     static void exec(TTuple &&tuple, TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
                         static const std::size_t OffsetedRem = TRem + TOff;
                         static_assert(OffsetedRem <= TupleSize, "Incorrect parameters");
@@ -220,7 +220,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TFunc>
                     static void exec(TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
                         static_assert(TRem <= TupleSize, "Incorrect TRem");
 
@@ -276,7 +276,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TFunc>
                     static void exec(TTuple &&tuple, TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
                         static_assert(TRem <= TupleSize, "Incorrect TRem");
 
@@ -332,7 +332,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TFunc>
                     static void exec(TTuple &&tuple, TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
                         static_assert(TRem <= TupleSize, "Incorrect TRem");
 
@@ -397,7 +397,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TValue, typename TFunc>
                     static constexpr TValue exec(TTuple &&tuple, const TValue &value, TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static_assert((TOff + TRem) <= std::tuple_size<Tuple>::value, "Incorrect params");
 
                         return tuple_accumulate_helper<TOff + 1, TRem - 1>::exec(
@@ -482,7 +482,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TValue, typename TFunc>
                     static constexpr TValue exec(const TValue &value, TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static_assert((TOff + TRem) <= std::tuple_size<Tuple>::value, "Incorrect TRem");
 
                         return tuple_type_accumulate_helper<TOff + 1, TRem - 1>::template exec<Tuple>(
@@ -562,8 +562,8 @@ namespace nil::crypto3 {
             /// @tparam TSecond Type of the second tuple.
             template<typename TFirst, typename TSecond>
             struct tuple_cat {
-                static_assert(nil::crypto3::detail::is_tuple<TFirst>::value, "TFirst must be tuple");
-                static_assert(nil::crypto3::detail::is_tuple<TSecond>::value, "TSecond must be tuple");
+                static_assert(marshalling::detail::is_tuple<TFirst>::value, "TFirst must be tuple");
+                static_assert(marshalling::detail::is_tuple<TSecond>::value, "TSecond must be tuple");
 
                 /// @brief Result type of tuples concatenation.
                 using type = typename std::decay<decltype(std::tuple_cat(std::declval<TFirst>(),
@@ -588,7 +588,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TFunc>
                     static void exec(std::size_t idx, TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
                         static_assert(TCount <= TupleSize, "Incorrect TCount");
                         static_assert(0U < TCount, "Incorrect instantiation");
@@ -653,7 +653,7 @@ namespace nil::crypto3 {
             template<typename TTuple, typename TFunc>
             void tuple_for_selected_type(std::size_t idx, TFunc &&func) {
                 using Tuple = typename std::decay<TTuple>::type;
-                static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "Provided tupe must be std::tuple");
+                static_assert(marshalling::detail::is_tuple<Tuple>::value, "Provided tupe must be std::tuple");
                 static const std::size_t TupleSize = std::tuple_size<Tuple>::value;
                 static_assert(0U < TupleSize, "Empty tuples are not supported");
 
@@ -694,8 +694,8 @@ namespace nil::crypto3 {
             /// @tparam TTuple Containing tuple
             template<typename TTail, typename TTuple>
             constexpr bool tuple_is_tail_of() {
-                static_assert(nil::crypto3::detail::is_tuple<TTail>::value, "TTail param must be tuple");
-                static_assert(nil::crypto3::detail::is_tuple<TTuple>::value, "TTuple param must be tuple");
+                static_assert(marshalling::detail::is_tuple<TTail>::value, "TTail param must be tuple");
+                static_assert(marshalling::detail::is_tuple<TTuple>::value, "TTuple param must be tuple");
                 return std::tuple_size<TTail>::value <= std::tuple_size<TTuple>::value
                        && detail::tuple_tail_check_helpler<
                            TTail, TTuple, std::tuple_size<TTuple>::value - std::tuple_size<TTail>::value>::value;
@@ -712,7 +712,7 @@ namespace nil::crypto3 {
                     template<typename TTuple, typename TFunc>
                     static constexpr bool check(TFunc &&func) {
                         using Tuple = typename std::decay<TTuple>::type;
-                        static_assert(nil::crypto3::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
+                        static_assert(marshalling::detail::is_tuple<Tuple>::value, "TTuple must be std::tuple");
                         static_assert(TRem <= std::tuple_size<Tuple>::value, "Incorrect TRem");
                         using ElemType = typename std::tuple_element<std::tuple_size<Tuple>::value - TRem, Tuple>::type;
                         return
@@ -740,7 +740,7 @@ namespace nil::crypto3 {
 
             template<typename TTuple, typename TFunc>
             constexpr bool tuple_type_is_any_of(TFunc &&func) {
-                static_assert(nil::crypto3::detail::is_tuple<TTuple>::value, "Tuple as argument is expected");
+                static_assert(marshalling::detail::is_tuple<TTuple>::value, "Tuple as argument is expected");
                 return detail::tuple_type_is_any_of_helper<std::tuple_size<TTuple>::value>::template check<TTuple>(
                     std::forward<TFunc>(func));
             }
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/types/adapter/num_value_multi_range_validator.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/types/adapter/num_value_multi_range_validator.hpp
index ecd41d36f1..deeb5ea09b 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/types/adapter/num_value_multi_range_validator.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/types/adapter/num_value_multi_range_validator.hpp
@@ -39,7 +39,7 @@ namespace nil::crypto3 {
                 class num_value_multi_range_validator : public TBase {
                     using base_impl_type = TBase;
 
-                    static_assert(nil::crypto3::detail::is_tuple<TRanges>::value, "TRanges must be a tuple");
+                    static_assert(marshalling::detail::is_tuple<TRanges>::value, "TRanges must be a tuple");
 
                 public:
                     using value_type = typename base_impl_type::value_type;
@@ -79,7 +79,7 @@ namespace nil::crypto3 {
                         template<typename TRange>
                         bool operator()(bool val) const {
                             static_cast<void>(val);
-                            static_assert(nil::crypto3::detail::is_tuple<TRange>::value,
+                            static_assert(marshalling::detail::is_tuple<TRange>::value,
                                           "TRange must be a tuple");
                             static_assert(std::tuple_size<TRange>::value == 2, "Tuple with 2 elements is expected");
                             using MinVal = typename std::tuple_element<0, TRange>::type;
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/types/array_list.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/types/array_list.hpp
index e3248764c0..441f5cb561 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/types/array_list.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/types/array_list.hpp
@@ -424,7 +424,7 @@ namespace nil::crypto3 {
             // Helper functions to convert to/from an arraylist.
             template<typename TFieldBase, typename TMarshalledElement, typename Range>
             typename std::enable_if<
-                nil::crypto3::detail::is_range<Range>::value, 
+                marshalling::detail::is_range<Range>::value, 
                 standard_array_list<TFieldBase, TMarshalledElement>>::type 
             fill_standard_array_list(
                     const Range& input_range,
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle.hpp
index f3a9abca07..676aa3ed57 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle.hpp
@@ -85,7 +85,7 @@ namespace nil::crypto3 {
             template<typename TFieldBase, typename TMembers, typename... TOptions>
             class bundle : private detail::adapt_basic_field_type<detail::basic_bundle<TFieldBase, TMembers>, TOptions...> {
                 using base_impl_type = detail::adapt_basic_field_type<detail::basic_bundle<TFieldBase, TMembers>, TOptions...>;
-                static_assert(nil::crypto3::detail::is_tuple<TMembers>::value,
+                static_assert(marshalling::detail::is_tuple<TMembers>::value,
                               "TMembers is expected to be a tuple of std::tuple<...>");
 
                 static_assert(1U <= std::tuple_size<TMembers>::value,
diff --git a/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle/basic_type.hpp b/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle/basic_type.hpp
index 5c7232cc9f..225205f6c2 100644
--- a/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle/basic_type.hpp
+++ b/crypto3/libs/marshalling/core/include/nil/marshalling/types/bundle/basic_type.hpp
@@ -407,7 +407,7 @@ namespace nil::crypto3 {
                         return write_no_status_helper<TIter>(iter);
                     }
 
-                    static_assert(nil::crypto3::detail::is_tuple<value_type>::value,
+                    static_assert(marshalling::detail::is_tuple<value_type>::value,
                                   "value_type must be tuple");
                     value_type members_;
                 };