diff --git a/include/bitcoin/system/typelets.hpp b/include/bitcoin/system/typelets.hpp
index 5c4c2b0ea7..e0f528dc4a 100644
--- a/include/bitcoin/system/typelets.hpp
+++ b/include/bitcoin/system/typelets.hpp
@@ -100,6 +100,20 @@ struct is_std_array_t<std_array<Type, Size>> : std::true_type {};
 template<typename Type>
 constexpr bool is_std_array = is_std_array_t<Type>::value;
 
+template<typename>
+struct is_std_vector_t : std::false_type {};
+template<typename Type>
+struct is_std_vector_t<std::vector<Type>> : std::true_type {};
+template<typename Type>
+constexpr bool is_std_vector = is_std_vector_t<Type>::value;
+
+template<typename>
+struct is_pmr_vector_t : std::false_type {};
+template<typename Type>
+struct is_pmr_vector_t<std_vector<Type>> : std::true_type {};
+template<typename Type>
+constexpr bool is_pmr_vector = is_pmr_vector_t<Type>::value;
+
 template <typename Type, std::enable_if_t<is_std_array<std::decay_t<Type>>, bool> = true>
 constexpr size_t array_count = std::tuple_size_v<std::decay_t<Type>>;
 
diff --git a/test/constraints.cpp b/test/constraints.cpp
index 40419d4b5c..ee30f5b084 100644
--- a/test/constraints.cpp
+++ b/test/constraints.cpp
@@ -597,6 +597,7 @@ static_assert(is_defined<if_integral_array<std_array<uint8_t, 0>>>);
 ////static_assert(!is_defined<if_integral_array<uint8_t>>);
 
 static_assert(is_defined<if_byte_insertable<std::string>>);
+static_assert(is_defined<if_byte_insertable<std::vector<uint8_t>>>);
 static_assert(is_defined<if_byte_insertable<std_vector<uint8_t>>>);
 ////static_assert(is_defined<if_byte_insertable<std_array<uint8_t, 42>>>);
 ////static_assert(!is_defined<if_byte_insertable<std::u32string>>);
diff --git a/test/typelets.cpp b/test/typelets.cpp
index f2d31d9d6b..22199dc6ec 100644
--- a/test/typelets.cpp
+++ b/test/typelets.cpp
@@ -314,12 +314,30 @@ static_assert(is_same_type<std::decay_t<uint8_t&>, uint8_t>);
 static_assert(is_same_type<const volatile uint8_t&, uint8_t>);
 static_assert(is_same_type<std::decay_t<const volatile uint8_t&>, uint8_t>);
 
-static_assert(is_std_array<std_array<uint8_t, 0>>);
-static_assert(is_std_array<std_array<base, 0>>);
+static_assert(is_std_array<std_array<uint8_t, 42>>);
+static_assert(is_std_array<std::array<uint8_t, 42>>);
+static_assert(!is_std_array<std::vector<uint8_t>>);
+static_assert(!is_std_array<std_vector<uint8_t>>);
 static_assert(!is_std_array<uint8_t>);
 static_assert(is_same_type<decltype(is_std_array<std_array<uint8_t, 0>>), const bool>);
 static_assert(is_same_type<decltype(is_std_array<const volatile std_array<uint8_t, 0>&>), const bool>);
 
+static_assert(is_std_vector<std::vector<uint8_t>>);
+static_assert(!is_std_vector<std_vector<uint8_t>>);
+static_assert(!is_std_vector<std_array<uint8_t, 42>>);
+static_assert(!is_std_vector<std::array<uint8_t, 42>>);
+static_assert(!is_std_vector<uint8_t>);
+static_assert(is_same_type<decltype(is_std_vector<std::vector<uint8_t>>), const bool>);
+static_assert(is_same_type<decltype(is_std_vector<const volatile std::vector<uint8_t>&>), const bool>);
+
+static_assert(is_pmr_vector<std_vector<uint8_t>>);
+static_assert(!is_pmr_vector<std::vector<uint8_t>>);
+static_assert(!is_pmr_vector<std_array<uint8_t, 42>>);
+static_assert(!is_pmr_vector<std::array<uint8_t, 42>>);
+static_assert(!is_pmr_vector<uint8_t>);
+static_assert(is_same_type<decltype(is_pmr_vector<std_vector<uint8_t>>), const bool>);
+static_assert(is_same_type<decltype(is_pmr_vector<const volatile std_vector<uint8_t>&>), const bool>);
+
 static_assert(array_count<std_array<uint8_t, 42>> == 42);
 static_assert(array_count<std_array<std_array<uint32_t, 42>, 24>> == 24);
 static_assert(array_count<const volatile std_array<std_array<uint32_t, 42>, 24>&> == 24);
@@ -352,15 +370,6 @@ static_assert(size_of<std_array<const volatile std_array<std_array<uint32_t, 42>
 static_assert(size_of<std_array<std_array<const volatile std_array<uint32_t, 42>, 24>, 8>>() == sizeof(uint32_t) * 42 * 24 * 8);
 static_assert(size_of<const volatile std_array<const volatile std_array<const volatile std_array<uint32_t, 42>, 24>, 8>&>() == sizeof(uint32_t) * 42 * 24 * 8);
 
-// std_array fails on "negative subscript"
-////static_assert(size_of<std_array<uint8_t, max_size_t>>() == sizeof(uint8_t) * max_size_t);
-////static_assert(size_of<std_array<uint16_t, max_size_t>>() == sizeof(uint16_t) * max_size_t);
-
-// multiply overlow
-////static_assert(size_of<std_array<uint16_t, to_half(max_size_t)>>() == sizeof(uint16_t) * to_half(max_size_t));
-
-// TODO: This is not currently restricted (is_std_array || !is_std_array).
-
 static_assert(is_uintx<uint5_t>);
 static_assert(is_uintx<uint11_t>);
 static_assert(is_uintx<uint48_t>);