diff --git a/src/binsrv/ctime_timestamp.cpp b/src/binsrv/ctime_timestamp.cpp
index 78e92f9..c048a26 100644
--- a/src/binsrv/ctime_timestamp.cpp
+++ b/src/binsrv/ctime_timestamp.cpp
@@ -15,6 +15,7 @@
 
 #include "binsrv/ctime_timestamp.hpp"
 
+#include <ctime>
 #include <exception>
 #include <ios>
 #include <istream>
@@ -45,14 +46,23 @@ ctime_timestamp::try_parse(std::string_view value_sv,
   return result;
 }
 
-[[nodiscard]] std::string ctime_timestamp::str() const {
+[[nodiscard]] std::string ctime_timestamp::iso_extended_str() const {
   return boost::posix_time::to_iso_extended_string(
       boost::posix_time::from_time_t(get_value()));
 }
 
+[[nodiscard]] std::string ctime_timestamp::simple_str() const {
+  return boost::posix_time::to_simple_string(
+      boost::posix_time::from_time_t(get_value()));
+}
+
+[[nodiscard]] ctime_timestamp ctime_timestamp::now() noexcept {
+  return ctime_timestamp{std::time(nullptr)};
+}
+
 std::ostream &operator<<(std::ostream &output,
                          const ctime_timestamp &timestamp) {
-  return output << timestamp.str();
+  return output << timestamp.iso_extended_str();
 }
 
 std::istream &operator>>(std::istream &input, ctime_timestamp &timestamp) {
diff --git a/src/binsrv/ctime_timestamp.hpp b/src/binsrv/ctime_timestamp.hpp
index e004b22..e60b04c 100644
--- a/src/binsrv/ctime_timestamp.hpp
+++ b/src/binsrv/ctime_timestamp.hpp
@@ -40,7 +40,10 @@ class [[nodiscard]] ctime_timestamp {
   void reset_to_epoch() noexcept { value_ = std::time_t{}; }
 
   [[nodiscard]] std::time_t get_value() const noexcept { return value_; }
-  [[nodiscard]] std::string str() const;
+  [[nodiscard]] std::string iso_extended_str() const;
+  [[nodiscard]] std::string simple_str() const;
+
+  [[nodiscard]] static ctime_timestamp now() noexcept;
 
   friend auto operator<=>(const ctime_timestamp &first,
                           const ctime_timestamp &second) = default;
diff --git a/src/binsrv/events/checksum_algorithm_type.hpp b/src/binsrv/events/checksum_algorithm_type.hpp
index 0bdc1e4..877f3b2 100644
--- a/src/binsrv/events/checksum_algorithm_type.hpp
+++ b/src/binsrv/events/checksum_algorithm_type.hpp
@@ -54,7 +54,7 @@ inline std::string_view to_string_view(checksum_algorithm_type code) noexcept {
 #undef BINSRV_CHECKSUM_ALGORITHM_TYPE_XY_MACRO
   // NOLINTNEXTLINE(llvm-qualified-auto,readability-qualified-auto)
   const auto fnd{std::ranges::find(labels, code, &nv_pair::first)};
-  return fnd == std::end(labels) ? ""sv : fnd->second;
+  return fnd == std::cend(labels) ? ""sv : fnd->second;
 }
 #undef BINSRV_CHECKSUM_ALGORITHM_TYPE_XY_SEQUENCE
 // NOLINTEND(cppcoreguidelines-macro-usage)
diff --git a/src/binsrv/events/code_type.hpp b/src/binsrv/events/code_type.hpp
index 44f3f5f..e72ea40 100644
--- a/src/binsrv/events/code_type.hpp
+++ b/src/binsrv/events/code_type.hpp
@@ -94,7 +94,7 @@ inline std::string_view to_string_view(code_type code) noexcept {
 #undef BINSRV_EVENTS_CODE_TYPE_XY_MACRO
   // NOLINTNEXTLINE(llvm-qualified-auto,readability-qualified-auto)
   const auto fnd{std::ranges::find(labels, code, &nv_pair::first)};
-  return fnd == std::end(labels) ? ""sv : fnd->second;
+  return fnd == std::cend(labels) ? ""sv : fnd->second;
 }
 #undef BINSRV_EVENTS_CODE_TYPE_XY_SEQUENCE
 // NOLINTEND(cppcoreguidelines-macro-usage)
diff --git a/src/binsrv/events/common_header.cpp b/src/binsrv/events/common_header.cpp
index a3569f1..edf06a2 100644
--- a/src/binsrv/events/common_header.cpp
+++ b/src/binsrv/events/common_header.cpp
@@ -15,19 +15,35 @@
 
 #include "binsrv/events/common_header.hpp"
 
+#include <cstdint>
+#include <iterator>
 #include <ostream>
+#include <stdexcept>
 
 #include <boost/align/align_up.hpp>
 
 #include "binsrv/ctime_timestamp.hpp"
 
+#include "binsrv/events/code_type.hpp"
 #include "binsrv/events/common_header_flag_type.hpp"
 #include "binsrv/events/common_header_view.hpp"
 
 #include "util/byte_span_fwd.hpp"
+#include "util/conversion_helpers.hpp"
+#include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
 
+common_header::common_header(
+    const ctime_timestamp &timestamp, code_type type_code,
+    // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
+    std::uint32_t server_id, std::uint32_t event_size,
+    std::uint32_t next_event_position, common_header_flag_set flags) noexcept
+    : timestamp_(static_cast<std::uint32_t>(timestamp.get_value())),
+      server_id_(server_id), event_size_(event_size),
+      next_event_position_(next_event_position), flags_(flags.get_bits()),
+      type_code_(util::to_underlying(type_code)) {}
+
 common_header::common_header(const common_header_view &view)
     : timestamp_{view.get_timestamp_raw()},
       server_id_{view.get_server_id_raw()},
@@ -50,6 +66,20 @@ common_header::common_header(const common_header_view &view)
 common_header::common_header(util::const_byte_span portion)
     : common_header{common_header_view{portion}} {}
 
+[[nodiscard]] common_header common_header::create_with_offset(
+    std::uint32_t offset, std::uint32_t event_size,
+    const ctime_timestamp &timestamp, code_type type_code,
+    std::uint32_t server_id, common_header_flag_set flags) noexcept {
+  // artificial ROTATE event must have next_event_position set to zero
+  const std::uint32_t next_event_position{
+      type_code == code_type::rotate &&
+              flags.has_element(common_header_flag_type::artificial)
+          ? 0U
+          : offset + event_size};
+  return common_header{timestamp,  type_code,           server_id,
+                       event_size, next_event_position, flags};
+}
+
 [[nodiscard]] ctime_timestamp common_header::get_timestamp() const noexcept {
   return common_header_view_base::get_timestamp_from_raw(get_timestamp_raw());
 }
@@ -58,6 +88,22 @@ common_header::common_header(util::const_byte_span portion)
   return common_header_view_base::get_flags_from_raw(get_flags_raw());
 }
 
+void common_header::encode_to(util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode common header");
+  }
+  const common_header_updatable_view common_header_uv{
+      destination.subspan(0U, calculate_encoded_size())};
+  common_header_uv.set_timestamp_raw(get_timestamp_raw());
+  common_header_uv.set_type_code_raw(get_type_code_raw());
+  common_header_uv.set_server_id_raw(get_server_id_raw());
+  common_header_uv.set_event_size_raw(get_event_size_raw());
+  common_header_uv.set_next_event_position_raw(get_next_event_position_raw());
+  common_header_uv.set_flags_raw(get_flags_raw());
+  destination = destination.subspan(calculate_encoded_size());
+}
+
 std::ostream &operator<<(std::ostream &output, const common_header &obj) {
   return output << "ts: " << obj.get_readable_timestamp()
                 << ", type: " << obj.get_readable_type_code()
diff --git a/src/binsrv/events/common_header.hpp b/src/binsrv/events/common_header.hpp
index 85a5128..5684717 100644
--- a/src/binsrv/events/common_header.hpp
+++ b/src/binsrv/events/common_header.hpp
@@ -39,9 +39,19 @@ class [[nodiscard]] common_header {
   static constexpr std::size_t size_in_bytes{
       common_header_view_base::size_in_bytes};
 
+  common_header(const ctime_timestamp &timestamp, code_type type_code,
+                std::uint32_t server_id, std::uint32_t event_size,
+                std::uint32_t next_event_position,
+                common_header_flag_set flags) noexcept;
   explicit common_header(const common_header_view &view);
   explicit common_header(util::const_byte_span portion);
 
+  [[nodiscard]] static common_header
+  create_with_offset(std::uint32_t offset, std::uint32_t event_size,
+                     const ctime_timestamp &timestamp, code_type type_code,
+                     std::uint32_t server_id,
+                     common_header_flag_set flags) noexcept;
+
   [[nodiscard]] std::uint32_t get_timestamp_raw() const noexcept {
     return timestamp_;
   }
@@ -81,6 +91,14 @@ class [[nodiscard]] common_header {
         get_flags_raw());
   }
 
+  [[nodiscard]] static std::size_t calculate_encoded_size() noexcept {
+    return size_in_bytes;
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const common_header &first,
+                         const common_header &second) = default;
+
 private:
   // the members are deliberately reordered for better packing
   std::uint32_t timestamp_{};           // 0
diff --git a/src/binsrv/events/common_header_flag_type.hpp b/src/binsrv/events/common_header_flag_type.hpp
index 0a81d9a..61f3b45 100644
--- a/src/binsrv/events/common_header_flag_type.hpp
+++ b/src/binsrv/events/common_header_flag_type.hpp
@@ -70,7 +70,7 @@ inline std::string_view to_string_view(common_header_flag_type code) noexcept {
 #undef BINSRV_EVENTS_COMMON_HEADER_FLAG_TYPE_XY_MACRO
   // NOLINTNEXTLINE(llvm-qualified-auto,readability-qualified-auto)
   const auto fnd{std::ranges::find(labels, code, &nv_pair::first)};
-  return fnd == std::end(labels) ? ""sv : fnd->second;
+  return fnd == std::cend(labels) ? ""sv : fnd->second;
 }
 #undef BINSRV_EVENTS_COMMON_HEADER_FLAG_TYPE_XY_SEQUENCE
 // NOLINTEND(cppcoreguidelines-macro-usage)
diff --git a/src/binsrv/events/common_header_view.cpp b/src/binsrv/events/common_header_view.cpp
index 21ccbec..2f193ff 100644
--- a/src/binsrv/events/common_header_view.cpp
+++ b/src/binsrv/events/common_header_view.cpp
@@ -44,7 +44,7 @@ namespace binsrv::events {
 [[nodiscard]] std::string
 common_header_view_base::get_readable_timestamp_from_raw(
     std::uint32_t timestamp) {
-  return get_timestamp_from_raw(timestamp).str();
+  return get_timestamp_from_raw(timestamp).iso_extended_str();
 }
 
 [[nodiscard]] code_type common_header_view_base::get_type_code_from_raw(
diff --git a/src/binsrv/events/empty_body.hpp b/src/binsrv/events/empty_body.hpp
index 4da3568..604652f 100644
--- a/src/binsrv/events/empty_body.hpp
+++ b/src/binsrv/events/empty_body.hpp
@@ -26,7 +26,16 @@ class [[nodiscard]] empty_body {
 public:
   static constexpr std::size_t size_in_bytes{0U};
 
+  empty_body() = default;
   explicit empty_body(util::const_byte_span portion);
+
+  [[nodiscard]] static std::size_t calculate_encoded_size() noexcept {
+    return size_in_bytes;
+  }
+  void encode_to(util::byte_span & /* destination */) const noexcept {}
+
+  friend bool operator==(const empty_body & /* first */,
+                         const empty_body & /* second */) = default;
 };
 
 } // namespace binsrv::events
diff --git a/src/binsrv/events/empty_post_header.hpp b/src/binsrv/events/empty_post_header.hpp
index 6c0011c..0ed1069 100644
--- a/src/binsrv/events/empty_post_header.hpp
+++ b/src/binsrv/events/empty_post_header.hpp
@@ -26,7 +26,16 @@ class [[nodiscard]] empty_post_header {
 public:
   static constexpr std::size_t size_in_bytes{0U};
 
+  empty_post_header() = default;
   explicit empty_post_header(util::const_byte_span portion);
+
+  [[nodiscard]] static std::size_t calculate_encoded_size() noexcept {
+    return size_in_bytes;
+  }
+  void encode_to(util::byte_span & /* destination */) const noexcept {}
+
+  friend bool operator==(const empty_post_header & /* first */,
+                         const empty_post_header & /* second */) = default;
 };
 
 } // namespace binsrv::events
diff --git a/src/binsrv/events/event.cpp b/src/binsrv/events/event.cpp
index 0b35d83..0c7acd8 100644
--- a/src/binsrv/events/event.cpp
+++ b/src/binsrv/events/event.cpp
@@ -17,9 +17,11 @@
 
 #include <array>
 #include <cassert>
+#include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <ostream>
+#include <stdexcept>
 #include <utility>
 #include <variant>
 
@@ -32,6 +34,8 @@
 
 #include "util/byte_span_fwd.hpp"
 #include "util/conversion_helpers.hpp"
+#include "util/crc_helpers.hpp"
+#include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
 
@@ -53,6 +57,49 @@ event::event(reader_context &context, const event_view &view)
 event::event(reader_context &context, util::const_byte_span portion)
     : event{context, event_view{context, portion}} {}
 
+template <typename T>
+concept encodable = requires(const T &obj, util::byte_span &destination) {
+  { obj.calculate_encoded_size() } -> std::same_as<std::size_t>;
+  { obj.encode_to(destination) };
+};
+
+[[nodiscard]] std::size_t event::calculate_encoded_size() const {
+  const auto size_calculation_visitor =
+      [](const auto &component) -> std::size_t {
+    if constexpr (encodable<decltype(component)>) {
+      return component.calculate_encoded_size();
+    } else {
+      util::exception_location().raise<std::logic_error>(
+          "calculate_encoded_size() not implemented for this event post header "
+          "/ body");
+    }
+  };
+  return common_header::calculate_encoded_size() +
+         std::visit(size_calculation_visitor, post_header_) +
+         std::visit(size_calculation_visitor, body_) +
+         (footer_ ? footer::calculate_encoded_size() : 0U);
+}
+void event::encode_to(util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode event");
+  }
+  const auto encoding_visitor = [&destination](const auto &component) {
+    if constexpr (encodable<decltype(component)>) {
+      component.encode_to(destination);
+    } else {
+      util::exception_location().raise<std::logic_error>(
+          "encode_to() not implemented for this event post header / body");
+    }
+  };
+  common_header_.encode_to(destination);
+  std::visit(encoding_visitor, post_header_);
+  std::visit(encoding_visitor, body_);
+  if (footer_) {
+    footer_->encode_to(destination);
+  }
+}
+
 void event::emplace_post_header(std::uint32_t encoded_server_version,
                                 code_type code, util::const_byte_span portion) {
   // our goal here is to initialize (emplace) a specific class inside
@@ -125,6 +172,25 @@ void event::emplace_body(std::uint32_t encoded_server_version, code_type code,
   (this->*emplace_functions[function_index])(encoded_server_version, portion);
 }
 
+void event::encode_and_checksum(event_storage &buffer, bool include_checksum) {
+  const auto size_with_footer{common_header_.get_event_size_raw()};
+  buffer.resize(size_with_footer);
+  util::byte_span output_span(std::data(buffer), size_with_footer);
+  // encoding event to the buffer
+  encode_to(output_span);
+  if (include_checksum) {
+    // calculating checksum
+    const auto size_wo_footer{size_with_footer -
+                              footer::calculate_encoded_size()};
+    const util::const_byte_span crc_span{std::data(buffer), size_wo_footer};
+    const auto crc{util::calculate_crc32(crc_span)};
+    footer_.emplace(crc);
+    // updating crc in the footer zone of the buffer
+    const footer_updatable_view footer_uv{output_span};
+    footer_uv.set_crc_raw(crc);
+  }
+}
+
 std::ostream &operator<<(std::ostream &output, const event &obj) {
   output << "| common header | " << obj.get_common_header() << " |";
 
@@ -136,9 +202,9 @@ std::ostream &operator<<(std::ostream &output, const event &obj) {
   output << " |\n| body          | ";
   std::visit(generic_printer, obj.get_generic_body());
   output << " |";
-  const auto &footer{obj.get_footer()};
-  if (footer) {
-    output << "\n| footer        | " << *footer << " |";
+  const auto &opt_footer{obj.get_footer()};
+  if (opt_footer.has_value()) {
+    output << "\n| footer        | " << *opt_footer << " |";
   }
   return output;
 }
diff --git a/src/binsrv/events/event.hpp b/src/binsrv/events/event.hpp
index a94b428..e82ceba 100644
--- a/src/binsrv/events/event.hpp
+++ b/src/binsrv/events/event.hpp
@@ -35,6 +35,7 @@
 #include "binsrv/events/anonymous_gtid_log_post_header_impl.hpp" // IWYU pragma: export
 #include "binsrv/events/code_type.hpp"
 #include "binsrv/events/common_header.hpp"                // IWYU pragma: export
+#include "binsrv/events/common_header_flag_type.hpp"
 #include "binsrv/events/event_view_fwd.hpp"
 #include "binsrv/events/footer.hpp"                       // IWYU pragma: export
 #include "binsrv/events/format_description_body_impl.hpp" // IWYU pragma: export
@@ -106,6 +107,27 @@ class [[nodiscard]] event {
 
   using optional_footer = std::optional<footer>;
 
+  template <code_type Code>
+  static event
+  create_event(std::uint32_t offset, const ctime_timestamp &timestamp,
+               std::uint32_t server_id, common_header_flag_set flags,
+               const generic_post_header<Code> &post_header,
+               const generic_body<Code> &body, bool include_checksum,
+               event_storage &buffer) {
+    return event{Code,        offset, timestamp,        server_id, flags,
+                 post_header, body,   include_checksum, &buffer};
+  }
+
+  template <code_type Code>
+  static event
+  create_event(std::uint32_t offset, const ctime_timestamp &timestamp,
+               std::uint32_t server_id, common_header_flag_set flags,
+               const generic_post_header<Code> &post_header,
+               const generic_body<Code> &body, bool include_checksum) {
+    return event{Code,        offset, timestamp,        server_id, flags,
+                 post_header, body,   include_checksum, nullptr};
+  }
+
   event(reader_context &context, const event_view &view);
   event(reader_context &context, util::const_byte_span portion);
 
@@ -127,9 +149,13 @@ class [[nodiscard]] event {
     return std::get<generic_body<Code>>(get_generic_body());
   }
 
-  [[nodiscard]] const optional_footer &get_footer() const noexcept {
-    return footer_;
-  }
+  [[nodiscard]] const optional_footer &get_footer() const { return footer_; }
+
+  [[nodiscard]] std::size_t calculate_encoded_size() const;
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const event & /* first */,
+                         const event & /* second */) = default;
 
 private:
   common_header common_header_;
@@ -137,6 +163,34 @@ class [[nodiscard]] event {
   body_variant body_{};
   optional_footer footer_{};
 
+  template <typename PostHeaderType, typename BodyType>
+  event(code_type code, std::uint32_t offset, const ctime_timestamp &timestamp,
+        std::uint32_t server_id, common_header_flag_set flags,
+        const PostHeaderType &post_header, const BodyType &body,
+        bool include_checksum, event_storage *buffer)
+      : common_header_{common_header::create_with_offset(
+            offset,
+            static_cast<std::uint32_t>(
+                common_header::calculate_encoded_size() +
+                post_header.calculate_encoded_size() +
+                body.calculate_encoded_size() +
+                (include_checksum ? footer::calculate_encoded_size() : 0U)),
+            timestamp, code, server_id, flags)},
+        post_header_{post_header}, body_{body}, footer_{} {
+    // format description events must always include footer
+    if (code == code_type::format_description) {
+      include_checksum = true;
+    }
+    if (buffer != nullptr) {
+      encode_and_checksum(*buffer, include_checksum);
+    } else {
+      if (include_checksum) {
+        event_storage local_buffer;
+        encode_and_checksum(local_buffer, true);
+      }
+    }
+  }
+
   template <typename T>
   void generic_emplace_post_header(std::uint32_t encoded_server_version,
                                    util::const_byte_span portion) {
@@ -159,6 +213,7 @@ class [[nodiscard]] event {
   }
   void emplace_body(std::uint32_t encoded_server_version, code_type code,
                     util::const_byte_span portion);
+  void encode_and_checksum(event_storage &buffer, bool include_checksum);
 };
 
 } // namespace binsrv::events
diff --git a/src/binsrv/events/event_fwd.hpp b/src/binsrv/events/event_fwd.hpp
index 38dc9f0..fa0c3d1 100644
--- a/src/binsrv/events/event_fwd.hpp
+++ b/src/binsrv/events/event_fwd.hpp
@@ -18,12 +18,18 @@
 
 #include <iosfwd>
 
+#include <boost/container/container_fwd.hpp>
+
 namespace binsrv::events {
 
 class event;
 
 std::ostream &operator<<(std::ostream &output, const event &obj);
 
+inline constexpr std::size_t expected_max_event_length{256U};
+using event_storage =
+    boost::container::small_vector<std::byte, expected_max_event_length>;
+
 } // namespace binsrv::events
 
 #endif // BINSRV_EVENTS_EVENT_FWD_HPP
diff --git a/src/binsrv/events/event_view.cpp b/src/binsrv/events/event_view.cpp
index 6044c85..9843bfb 100644
--- a/src/binsrv/events/event_view.cpp
+++ b/src/binsrv/events/event_view.cpp
@@ -77,7 +77,7 @@ event_view_base::event_view_base(const reader_context &context,
       get_common_header_size() + get_post_header_size() + get_footer_size();
   if (get_total_size() < group_size) {
     util::exception_location().raise<std::logic_error>(
-        "not enough data for event post-header + body + footer");
+        "not enough data for event post header + body + footer");
   }
 
   // optional checksum verification
diff --git a/src/binsrv/events/event_view.hpp b/src/binsrv/events/event_view.hpp
index 7df5fce..801a821 100644
--- a/src/binsrv/events/event_view.hpp
+++ b/src/binsrv/events/event_view.hpp
@@ -57,7 +57,7 @@ class [[nodiscard]] event_view_base {
   [[nodiscard]] common_header_updatable_view
   get_common_header_updatable_view() const;
 
-  // post-header section
+  // post header section
   [[nodiscard]] std::size_t get_post_header_size() const noexcept {
     return post_header_size_;
   }
@@ -130,8 +130,8 @@ class [[nodiscard]] event_updatable_view : private event_view_base {
   // const util::const_byte_span ro_event_data_block{...};
   // const binsrv::events::event_view event_v{context, ro_event_data_block};
   // using event_buffer_type = std::vector<std::byte>;
-  // event_buffer_type event_copy(std::begin(ro_event_data_block),
-  //                              std::end(ro_event_data_block));
+  // event_buffer_type event_copy(std::cbegin(ro_event_data_block),
+  //                              std::cend(ro_event_data_block));
   // const binsrv::events::event_updatable_view event_copy_uv{context,
   //                                                          event_copy};
   // {
@@ -190,7 +190,7 @@ class [[nodiscard]] event_updatable_view : private event_view_base {
   // common header section
   using event_view_base::get_common_header_size;
 
-  // post-header section
+  // post header section
   using event_view_base::get_post_header_size;
 
   // body section
@@ -230,7 +230,7 @@ class [[nodiscard]] event_view : private event_view_base {
   using event_view_base::get_common_header_raw;
   using event_view_base::get_common_header_view;
 
-  // post-header section
+  // post header section
   using event_view_base::get_post_header_size;
   using event_view_base::get_post_header_raw;
 
diff --git a/src/binsrv/events/footer.cpp b/src/binsrv/events/footer.cpp
index e79f7c8..cf35956 100644
--- a/src/binsrv/events/footer.cpp
+++ b/src/binsrv/events/footer.cpp
@@ -15,13 +15,16 @@
 
 #include "binsrv/events/footer.hpp"
 
+#include <iterator>
 #include <ostream>
+#include <stdexcept>
 
 #include <boost/align/align_up.hpp>
 
 #include "binsrv/events/footer_view.hpp"
 
 #include "util/byte_span_fwd.hpp"
+#include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
 
@@ -38,6 +41,17 @@ footer::footer(const footer_view &view) : crc_(view.get_crc_raw()) {
 
 footer::footer(util::const_byte_span portion) : footer{footer_view{portion}} {}
 
+void footer::encode_to(util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode footer");
+  }
+  const footer_updatable_view footer_uv{
+      destination.subspan(0U, calculate_encoded_size())};
+  footer_uv.set_crc_raw(get_crc_raw());
+  destination = destination.subspan(calculate_encoded_size());
+}
+
 std::ostream &operator<<(std::ostream &output, const footer &obj) {
   return output << "crc: " << obj.get_readable_crc();
 }
diff --git a/src/binsrv/events/footer.hpp b/src/binsrv/events/footer.hpp
index 5dfc350..c805160 100644
--- a/src/binsrv/events/footer.hpp
+++ b/src/binsrv/events/footer.hpp
@@ -30,6 +30,8 @@ class [[nodiscard]] footer {
 public:
   static constexpr std::size_t size_in_bytes{footer_view_base::size_in_bytes};
 
+  explicit footer(std::uint32_t crc) noexcept : crc_{crc} {}
+
   explicit footer(const footer_view &view);
   explicit footer(util::const_byte_span portion);
 
@@ -38,6 +40,13 @@ class [[nodiscard]] footer {
     return footer_view_base::get_readable_crc_from_raw(get_crc_raw());
   }
 
+  [[nodiscard]] static std::size_t calculate_encoded_size() noexcept {
+    return size_in_bytes;
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const footer &first, const footer &second) = default;
+
 private:
   std::uint32_t crc_{};
 };
diff --git a/src/binsrv/events/footer_fwd.hpp b/src/binsrv/events/footer_fwd.hpp
index 42e515e..09dd7c2 100644
--- a/src/binsrv/events/footer_fwd.hpp
+++ b/src/binsrv/events/footer_fwd.hpp
@@ -17,6 +17,7 @@
 #define BINSRV_EVENTS_FOOTER_FWD_HPP
 
 #include <iosfwd>
+
 namespace binsrv::events {
 
 class footer;
diff --git a/src/binsrv/events/format_description_body_impl.cpp b/src/binsrv/events/format_description_body_impl.cpp
index 1216f27..dac0774 100644
--- a/src/binsrv/events/format_description_body_impl.cpp
+++ b/src/binsrv/events/format_description_body_impl.cpp
@@ -28,11 +28,16 @@
 
 #include "util/byte_span.hpp"
 #include "util/byte_span_extractors.hpp"
+#include "util/byte_span_inserters.hpp"
 #include "util/conversion_helpers.hpp"
 #include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
 
+generic_body_impl<code_type::format_description>::generic_body_impl(
+    checksum_algorithm_type checksum_algorithm) noexcept
+    : checksum_algorithm_{util::to_underlying(checksum_algorithm)} {}
+
 generic_body_impl<code_type::format_description>::generic_body_impl(
     util::const_byte_span portion) {
   // TODO: rework with direct member initialization
@@ -77,6 +82,15 @@ generic_body_impl<code_type::format_description>::has_checksum_algorithm()
   return checksum_algorithm != checksum_algorithm_type::off;
 }
 
+void generic_body_impl<code_type::format_description>::encode_to(
+    util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode format description body");
+  }
+  util::insert_fixed_int_to_byte_span(destination, checksum_algorithm_);
+}
+
 std::ostream &
 operator<<(std::ostream &output,
            const generic_body_impl<code_type::format_description> &obj) {
diff --git a/src/binsrv/events/format_description_body_impl.hpp b/src/binsrv/events/format_description_body_impl.hpp
index 7d1ea48..685a9e5 100644
--- a/src/binsrv/events/format_description_body_impl.hpp
+++ b/src/binsrv/events/format_description_body_impl.hpp
@@ -34,6 +34,8 @@ class [[nodiscard]] generic_body_impl<code_type::format_description> {
 public:
   static constexpr std::size_t size_in_bytes{1U};
 
+  explicit generic_body_impl(
+      checksum_algorithm_type checksum_algorithm) noexcept;
   explicit generic_body_impl(util::const_byte_span portion);
 
   [[nodiscard]] std::uint8_t get_checksum_algorithm_raw() const noexcept {
@@ -49,6 +51,14 @@ class [[nodiscard]] generic_body_impl<code_type::format_description> {
 
   [[nodiscard]] bool has_checksum_algorithm() const noexcept;
 
+  [[nodiscard]] static std::size_t calculate_encoded_size() noexcept {
+    return size_in_bytes;
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const generic_body_impl &first,
+                         const generic_body_impl &second) = default;
+
 private:
   std::uint8_t checksum_algorithm_{};
 };
diff --git a/src/binsrv/events/format_description_post_header_impl.cpp b/src/binsrv/events/format_description_post_header_impl.cpp
index 046af07..0b1754b 100644
--- a/src/binsrv/events/format_description_post_header_impl.cpp
+++ b/src/binsrv/events/format_description_post_header_impl.cpp
@@ -15,7 +15,10 @@
 
 #include "binsrv/events/format_description_post_header_impl.hpp"
 
+#include <algorithm>
+#include <cstddef>
 #include <cstdint>
+#include <ctime>
 #include <ostream>
 #include <span>
 #include <stdexcept>
@@ -24,8 +27,7 @@
 
 #include <boost/align/align_up.hpp>
 
-#include <boost/date_time/posix_time/conversion.hpp>
-#include <boost/date_time/posix_time/time_formatters.hpp>
+#include "binsrv/ctime_timestamp.hpp"
 
 #include "binsrv/events/code_type.hpp"
 #include "binsrv/events/protocol_traits.hpp"
@@ -33,11 +35,36 @@
 #include "util/bounded_string_storage.hpp"
 #include "util/byte_span.hpp"
 #include "util/byte_span_extractors.hpp"
+#include "util/byte_span_inserters.hpp"
 #include "util/exception_location_helpers.hpp"
 #include "util/semantic_version.hpp"
 
 namespace binsrv::events {
 
+generic_post_header_impl<code_type::format_description>::
+    generic_post_header_impl(
+        std::uint16_t binlog_version,
+        const util::semantic_version &server_version,
+        const ctime_timestamp &create_timestamp,
+        std::size_t common_header_length,
+        const post_header_length_container &post_header_lengths)
+    : create_timestamp_{static_cast<std::uint32_t>(
+          create_timestamp.get_value())},
+      server_version_{}, binlog_version_{binlog_version},
+      post_header_lengths_{post_header_lengths},
+      common_header_length_{static_cast<std::uint8_t>(common_header_length)} {
+  const auto readable_server_version{server_version.get_string()};
+  const auto truncated_length{
+      std::min(std::size(readable_server_version),
+               server_version_storage::static_capacity)};
+  const std::string_view readable_server_version_sv(
+      readable_server_version.c_str(), truncated_length);
+  const auto readable_server_version_span{
+      util::as_const_byte_span(readable_server_version_sv)};
+  server_version_.assign(std::cbegin(readable_server_version_span),
+                         std::cend(readable_server_version_span));
+}
+
 generic_post_header_impl<code_type::format_description>::
     generic_post_header_impl(std::uint32_t encoded_server_version,
                              util::const_byte_span portion) {
@@ -90,12 +117,12 @@ generic_post_header_impl<code_type::format_description>::
 
   if (std::size(portion) != get_size_in_bytes(encoded_server_version)) {
     util::exception_location().raise<std::invalid_argument>(
-        "invalid format_description event post-header length");
+        "invalid format_description event post header length");
   }
 
   auto remainder = portion;
   util::extract_fixed_int_from_byte_span(remainder, binlog_version_);
-  server_version_.resize(decltype(server_version_)::capacity());
+  server_version_.resize(decltype(server_version_)::static_capacity);
   util::extract_byte_span_from_byte_span(remainder,
                                          util::byte_span{server_version_});
   util::normalize_for_c_str(server_version_);
@@ -109,32 +136,69 @@ generic_post_header_impl<code_type::format_description>::
                                          post_header_lengths_subrange);
 }
 
-[[nodiscard]] std::string_view
-generic_post_header_impl<code_type::format_description>::get_server_version()
+[[nodiscard]] std::string_view generic_post_header_impl<
+    code_type::format_description>::get_readable_server_version()
     const noexcept {
   return util::to_string_view(server_version_);
 }
+[[nodiscard]] util::semantic_version
+generic_post_header_impl<code_type::format_description>::get_server_version()
+    const {
+  return util::semantic_version{get_readable_server_version()};
+}
 
 [[nodiscard]] std::uint32_t generic_post_header_impl<
     code_type::format_description>::get_encoded_server_version()
     const noexcept {
-  return util::semantic_version{get_server_version()}.get_encoded();
+  return get_server_version().get_encoded();
+}
+
+[[nodiscard]] ctime_timestamp
+generic_post_header_impl<code_type::format_description>::get_create_timestamp()
+    const noexcept {
+  return ctime_timestamp{static_cast<std::time_t>(get_create_timestamp_raw())};
 }
 
 [[nodiscard]] std::string generic_post_header_impl<
     code_type::format_description>::get_readable_create_timestamp() const {
-  return boost::posix_time::to_simple_string(
-      boost::posix_time::from_time_t(get_create_timestamp()));
+  return get_create_timestamp().simple_str();
+}
+
+void generic_post_header_impl<code_type::format_description>::encode_to(
+    util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode format description event post header");
+  }
+  util::insert_fixed_int_to_byte_span(destination, get_binlog_version_raw());
+
+  const util::const_byte_span server_version_span{get_server_version_raw()};
+  util::insert_byte_span_to_byte_span(destination, server_version_span);
+  const server_version_storage zero_filled_buffer(
+      server_version_storage::static_capacity - std::size(server_version_span));
+  util::insert_byte_span_to_byte_span(
+      destination, util::const_byte_span{zero_filled_buffer});
+
+  util::insert_fixed_int_to_byte_span(destination, get_create_timestamp_raw());
+  util::insert_fixed_int_to_byte_span(destination,
+                                      get_common_header_length_raw());
+  const auto expected_subrange_length{
+      get_number_of_events(get_encoded_server_version()) - 1U};
+  const std::span<const encoded_post_header_length_type>
+      post_header_lengths_subrange{std::data(get_post_header_lengths_raw()),
+                                   expected_subrange_length};
+  util::insert_byte_span_to_byte_span(destination,
+                                      post_header_lengths_subrange);
 }
 
 std::ostream &
 operator<<(std::ostream &output,
            const generic_post_header_impl<code_type::format_description> &obj) {
   output << "binlog version: " << obj.get_binlog_version_raw()
-         << ", server version: " << obj.get_server_version()
+         << ", server version: " << obj.get_readable_server_version()
          << ", create timestamp: " << obj.get_readable_create_timestamp()
          << ", common header length: " << obj.get_common_header_length()
-         << "\npost-header lengths: {\n";
+         << "\npost header lengths: {\n";
   print_post_header_lengths(output, obj.get_encoded_server_version(),
                             obj.get_post_header_lengths_raw());
   output << "\n}";
diff --git a/src/binsrv/events/format_description_post_header_impl.hpp b/src/binsrv/events/format_description_post_header_impl.hpp
index e22b9b3..1f8f8ee 100644
--- a/src/binsrv/events/format_description_post_header_impl.hpp
+++ b/src/binsrv/events/format_description_post_header_impl.hpp
@@ -25,10 +25,13 @@
 #include <string>
 #include <string_view>
 
+#include "binsrv/ctime_timestamp_fwd.hpp"
+
 #include "binsrv/events/protocol_traits.hpp"
 
 #include "util/bounded_string_storage.hpp"
 #include "util/byte_span_fwd.hpp"
+#include "util/semantic_version_fwd.hpp"
 
 namespace binsrv::events {
 
@@ -48,6 +51,11 @@ class [[nodiscard]] generic_post_header_impl<code_type::format_description> {
   using server_version_storage =
       util::bounded_string_storage<server_version_length>;
 
+  generic_post_header_impl(
+      std::uint16_t binlog_version,
+      const util::semantic_version &server_version,
+      const ctime_timestamp &create_timestamp, std::size_t common_header_length,
+      const post_header_length_container &post_header_lengths);
   generic_post_header_impl(std::uint32_t encoded_server_version,
                            util::const_byte_span portion);
 
@@ -60,19 +68,18 @@ class [[nodiscard]] generic_post_header_impl<code_type::format_description> {
     return server_version_;
   }
 
-  [[nodiscard]] std::string_view get_server_version() const noexcept;
+  [[nodiscard]] std::string_view get_readable_server_version() const noexcept;
+  [[nodiscard]] util::semantic_version get_server_version() const;
 
   [[nodiscard]] std::uint32_t get_encoded_server_version() const noexcept;
 
   [[nodiscard]] std::uint32_t get_create_timestamp_raw() const noexcept {
     return create_timestamp_;
   }
-  [[nodiscard]] std::time_t get_create_timestamp() const noexcept {
-    return static_cast<std::time_t>(get_create_timestamp_raw());
-  }
+  [[nodiscard]] ctime_timestamp get_create_timestamp() const noexcept;
   [[nodiscard]] std::string get_readable_create_timestamp() const;
 
-  [[nodiscard]] std::uint16_t get_common_header_length_raw() const noexcept {
+  [[nodiscard]] std::uint8_t get_common_header_length_raw() const noexcept {
     return common_header_length_;
   }
   [[nodiscard]] std::size_t get_common_header_length() const noexcept {
@@ -84,6 +91,14 @@ class [[nodiscard]] generic_post_header_impl<code_type::format_description> {
     return post_header_lengths_;
   }
 
+  [[nodiscard]] std::size_t calculate_encoded_size() const noexcept {
+    return get_size_in_bytes(get_encoded_server_version());
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const generic_post_header_impl &first,
+                         const generic_post_header_impl &second) = default;
+
 private:
   // the members are deliberately reordered for better packing
   std::uint32_t create_timestamp_{};                   // 2
diff --git a/src/binsrv/events/gtid_log_body.hpp b/src/binsrv/events/gtid_log_body.hpp
index e94f545..2a81684 100644
--- a/src/binsrv/events/gtid_log_body.hpp
+++ b/src/binsrv/events/gtid_log_body.hpp
@@ -87,6 +87,9 @@ class [[nodiscard]] gtid_log_body {
     return commit_group_ticket_;
   }
 
+  friend bool operator==(const gtid_log_body & /* first */,
+                         const gtid_log_body & /* second */) = default;
+
 private:
   static constexpr std::uint64_t unset_commit_timestamp{
       std::numeric_limits<std::uint64_t>::max()};
diff --git a/src/binsrv/events/gtid_log_flag_type.hpp b/src/binsrv/events/gtid_log_flag_type.hpp
index 426d493..932dedb 100644
--- a/src/binsrv/events/gtid_log_flag_type.hpp
+++ b/src/binsrv/events/gtid_log_flag_type.hpp
@@ -59,7 +59,7 @@ inline std::string_view to_string_view(gtid_log_flag_type code) noexcept {
 #undef BINSRV_EVENTS_GTID_LOG_FLAG_TYPE_XY_MACRO
   // NOLINTNEXTLINE(llvm-qualified-auto,readability-qualified-auto)
   const auto fnd{std::ranges::find(labels, code, &nv_pair::first)};
-  return fnd == std::end(labels) ? ""sv : fnd->second;
+  return fnd == std::cend(labels) ? ""sv : fnd->second;
 }
 #undef BINSRV_EVENTS_GTID_LOG_FLAG_TYPE_XY_SEQUENCE
 // NOLINTEND(cppcoreguidelines-macro-usage)
diff --git a/src/binsrv/events/gtid_log_post_header.cpp b/src/binsrv/events/gtid_log_post_header.cpp
index 35d23e7..46b56ae 100644
--- a/src/binsrv/events/gtid_log_post_header.cpp
+++ b/src/binsrv/events/gtid_log_post_header.cpp
@@ -96,7 +96,7 @@ gtid_log_post_header::gtid_log_post_header(util::const_byte_span portion) {
 
   if (std::size(portion) != size_in_bytes) {
     util::exception_location().raise<std::invalid_argument>(
-        "invalid gtid_log event post-header length");
+        "invalid gtid_log event post header length");
   }
 
   // https://github.com/mysql/mysql-server/blob/mysql-8.0.43/libbinlogevents/src/control_events.cpp#L428
@@ -111,7 +111,7 @@ gtid_log_post_header::gtid_log_post_header(util::const_byte_span portion) {
   util::extract_fixed_int_from_byte_span(remainder, logical_ts_code_);
   if (logical_ts_code_ != expected_logical_ts_code) {
     util::exception_location().raise<std::invalid_argument>(
-        "unsupported logical timestamp code in gtid_log post-header");
+        "unsupported logical timestamp code in gtid_log post header");
   }
   util::extract_fixed_int_from_byte_span(remainder, last_committed_);
   util::extract_fixed_int_from_byte_span(remainder, sequence_number_);
diff --git a/src/binsrv/events/gtid_log_post_header.hpp b/src/binsrv/events/gtid_log_post_header.hpp
index 8eb437f..f50c9c0 100644
--- a/src/binsrv/events/gtid_log_post_header.hpp
+++ b/src/binsrv/events/gtid_log_post_header.hpp
@@ -70,6 +70,9 @@ class [[nodiscard]] gtid_log_post_header {
     return sequence_number_;
   }
 
+  friend bool operator==(const gtid_log_post_header & /* first */,
+                         const gtid_log_post_header & /* second */) = default;
+
 private:
   // the members are deliberately reordered for better packing
   std::uint8_t flags_{};           // 0
diff --git a/src/binsrv/events/gtid_tagged_log_body_impl.cpp b/src/binsrv/events/gtid_tagged_log_body_impl.cpp
index 7649da8..88a668d 100644
--- a/src/binsrv/events/gtid_tagged_log_body_impl.cpp
+++ b/src/binsrv/events/gtid_tagged_log_body_impl.cpp
@@ -45,6 +45,7 @@
 #include "util/bounded_string_storage.hpp"
 #include "util/byte_span.hpp"
 #include "util/byte_span_extractors.hpp"
+#include "util/conversion_helpers.hpp"
 #include "util/exception_location_helpers.hpp"
 #include "util/flag_set.hpp"
 #include "util/semantic_version.hpp"
@@ -290,7 +291,7 @@ void generic_body_impl<code_type::gtid_tagged_log>::process_field_data(
         util::exception_location().raise<std::invalid_argument>(
             "gtid_tagged_log event body is too short to extract uuid");
       }
-      uuid_byte = static_cast<std::byte>(extracted_uuid_byte);
+      uuid_byte = util::from_underlying<std::byte>(extracted_uuid_byte);
     }
   } break;
   case field_id_type::gno:
diff --git a/src/binsrv/events/gtid_tagged_log_body_impl.hpp b/src/binsrv/events/gtid_tagged_log_body_impl.hpp
index 54dbb9d..db465db 100644
--- a/src/binsrv/events/gtid_tagged_log_body_impl.hpp
+++ b/src/binsrv/events/gtid_tagged_log_body_impl.hpp
@@ -129,6 +129,9 @@ template <> class [[nodiscard]] generic_body_impl<code_type::gtid_tagged_log> {
     return commit_group_ticket_;
   }
 
+  friend bool operator==(const generic_body_impl & /* first */,
+                         const generic_body_impl & /* second */) = default;
+
 private:
   static constexpr std::uint64_t unset_commit_timestamp{
       std::numeric_limits<std::uint64_t>::max()};
diff --git a/src/binsrv/events/previous_gtids_log_body_impl.cpp b/src/binsrv/events/previous_gtids_log_body_impl.cpp
index 8053ad2..97b218a 100644
--- a/src/binsrv/events/previous_gtids_log_body_impl.cpp
+++ b/src/binsrv/events/previous_gtids_log_body_impl.cpp
@@ -15,10 +15,12 @@
 
 #include "binsrv/events/previous_gtids_log_body_impl.hpp"
 
+#include <algorithm>
 #include <cstddef>
 #include <iterator>
 #include <ostream>
 #include <span>
+#include <stdexcept>
 #include <string>
 
 #include <boost/lexical_cast.hpp>
@@ -30,9 +32,17 @@
 
 #include "util/byte_span.hpp"
 #include "util/byte_span_extractors.hpp"
+#include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
 
+generic_body_impl<code_type::previous_gtids_log>::generic_body_impl(
+    const gtids::gtid_set &gtids)
+    : gtids_(gtids.calculate_encoded_size()) {
+  util::byte_span gtids_span{gtids_};
+  gtids.encode_to(gtids_span);
+}
+
 generic_body_impl<code_type::previous_gtids_log>::generic_body_impl(
     util::const_byte_span portion) {
   // TODO: rework with direct member initialization
@@ -40,8 +50,8 @@ generic_body_impl<code_type::previous_gtids_log>::generic_body_impl(
   auto remainder = portion;
   const std::size_t gtids_size{std::size(remainder)};
   gtids_.resize(gtids_size);
-  const std::span<gtids::gtid_set_storage::value_type> gtids_range{gtids_};
-  util::extract_byte_span_from_byte_span(remainder, gtids_range);
+  const util::byte_span gtids_span{gtids_};
+  util::extract_byte_span_from_byte_span(remainder, gtids_span);
 }
 
 [[nodiscard]] gtids::gtid_set
@@ -54,6 +64,16 @@ generic_body_impl<code_type::previous_gtids_log>::get_readable_gtids() const {
   return boost::lexical_cast<std::string>(get_gtids());
 }
 
+void generic_body_impl<code_type::previous_gtids_log>::encode_to(
+    util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode previous gtids log event body");
+  }
+  std::ranges::copy(gtids_, std::begin(destination));
+  destination = destination.subspan(calculate_encoded_size());
+}
+
 std::ostream &
 operator<<(std::ostream &output,
            const generic_body_impl<code_type::previous_gtids_log> &obj) {
diff --git a/src/binsrv/events/previous_gtids_log_body_impl.hpp b/src/binsrv/events/previous_gtids_log_body_impl.hpp
index fd1fee3..851dc15 100644
--- a/src/binsrv/events/previous_gtids_log_body_impl.hpp
+++ b/src/binsrv/events/previous_gtids_log_body_impl.hpp
@@ -35,6 +35,7 @@ class [[nodiscard]] generic_body_impl<code_type::previous_gtids_log> {
 public:
   // https://github.com/mysql/mysql-server/blob/mysql-8.4.6/libs/mysql/binlog/event/control_events.h#L1354
 
+  explicit generic_body_impl(const gtids::gtid_set &gtids);
   explicit generic_body_impl(util::const_byte_span portion);
 
   [[nodiscard]] const gtids::gtid_set_storage &get_gtids_raw() const noexcept {
@@ -43,6 +44,14 @@ class [[nodiscard]] generic_body_impl<code_type::previous_gtids_log> {
   [[nodiscard]] gtids::gtid_set get_gtids() const;
   [[nodiscard]] std::string get_readable_gtids() const;
 
+  [[nodiscard]] std::size_t calculate_encoded_size() const noexcept {
+    return std::size(gtids_);
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const generic_body_impl &first,
+                         const generic_body_impl &second) = default;
+
 private:
   gtids::gtid_set_storage gtids_;
 };
diff --git a/src/binsrv/events/protocol_traits.cpp b/src/binsrv/events/protocol_traits.cpp
index 098bebd..67926dc 100644
--- a/src/binsrv/events/protocol_traits.cpp
+++ b/src/binsrv/events/protocol_traits.cpp
@@ -102,9 +102,9 @@ void validate_post_header_lengths(
                                unspecified_post_header_length) ||
                real == expected;
       })};
-  if (length_mismatch_result.in2 != std::end(hardcoded)) {
+  if (length_mismatch_result.in2 != std::cend(hardcoded)) {
     const auto offset{static_cast<std::size_t>(
-        std::distance(std::begin(hardcoded), length_mismatch_result.in2))};
+        std::distance(std::cbegin(hardcoded), length_mismatch_result.in2))};
     const std::string label{
         to_string_view(util::index_to_enum<code_type>(offset + 1U))};
     util::exception_location().raise<std::logic_error>(
diff --git a/src/binsrv/events/reader_context.cpp b/src/binsrv/events/reader_context.cpp
index 8f78af3..b856efc 100644
--- a/src/binsrv/events/reader_context.cpp
+++ b/src/binsrv/events/reader_context.cpp
@@ -55,6 +55,65 @@ reader_context::get_current_post_header_length(code_type code) const noexcept {
                                          post_header_lengths_, code);
 }
 
+[[nodiscard]] const post_header_length_container &
+reader_context::get_hardcoded_post_header_lengths(
+    std::uint32_t encoded_server_version) noexcept {
+  // here we use a trick with a templated lambda to initialize constexpr
+  // arrays which would have expected post header lengths for all
+  // event codes based on generic_post_header<xxx>::get_size_in_bytes()
+
+  // we ignore the very first element in the code_type enum
+  // (code_type::unknown) since the post header length for this value is
+  // simply not included into FDE post header
+
+  using size_in_bytes_helper =
+      decltype([]<std::size_t Index>(
+                   std::uint32_t version) constexpr -> std::size_t {
+        constexpr auto code{util::index_to_enum<code_type>(Index + 1U)};
+        if constexpr (requires(std::uint32_t test_version) {
+                        {
+                          generic_post_header<code>::get_size_in_bytes(
+                              test_version)
+                        } -> std::same_as<std::size_t>;
+                      }) {
+          return generic_post_header<code>::get_size_in_bytes(version);
+        } else {
+          return generic_post_header<code>::size_in_bytes;
+        }
+      });
+
+  constexpr auto hardcoded_post_header_lengths_generator{
+      []<std::size_t... IndexPack>(std::uint32_t version,
+                                   std::index_sequence<IndexPack...>) constexpr
+          -> post_header_length_container {
+        return {
+          static_cast<encoded_post_header_length_type>(
+              size_in_bytes_helper{}.template operator()<IndexPack>(version))...
+        };
+      }};
+
+  // the remainder of the 'earliest_supported_post_header_lengths' container
+  // will be default-initialized
+  static constexpr post_header_length_container
+      earliest_supported_post_header_lengths{
+          hardcoded_post_header_lengths_generator(
+              earliest_supported_protocol_server_version,
+              std::make_index_sequence<
+                  get_number_of_events(
+                      earliest_supported_protocol_server_version) -
+                  1U>{})};
+  static constexpr post_header_length_container
+      latest_known_post_header_lengths{hardcoded_post_header_lengths_generator(
+          latest_known_protocol_server_version,
+          std::make_index_sequence<get_number_of_events(
+                                       latest_known_protocol_server_version) -
+                                   1U>{})};
+
+  return encoded_server_version < latest_known_protocol_server_version
+             ? earliest_supported_post_header_lengths
+             : latest_known_post_header_lengths;
+}
+
 void reader_context::process_event(const event &current_event) {
   bool processed{false};
   while (!processed) {
@@ -195,7 +254,7 @@ reader_context::process_event_in_format_description_expected_state(
       common_header_flag_type::artificial)};
   if (is_artificial) {
     util::exception_location().raise<std::logic_error>(
-        "format description event is not expected to be artificual");
+        "format description event is not expected to be artificial");
   }
 
   const auto &post_header{
@@ -583,63 +642,4 @@ void reader_context::finish_transaction() {
   current_transaction_length_ = 0U;
 }
 
-[[nodiscard]] const post_header_length_container &
-reader_context::get_hardcoded_post_header_lengths(
-    std::uint32_t encoded_server_version) noexcept {
-  // here we use a trick with a templated lambda to initialize constexpr
-  // arrays which would have expected post header lengths for all
-  // event codes based on generic_post_header<xxx>::get_size_in_bytes()
-
-  // we ignore the very first element in the code_type enum
-  // (code_type::unknown) since the post header length for this value is
-  // simply not included into FDE post header
-
-  using size_in_bytes_helper =
-      decltype([]<std::size_t Index>(
-                   std::uint32_t version) constexpr -> std::size_t {
-        constexpr auto code{util::index_to_enum<code_type>(Index + 1U)};
-        if constexpr (requires(std::uint32_t test_version) {
-                        {
-                          generic_post_header<code>::get_size_in_bytes(
-                              test_version)
-                        } -> std::same_as<std::size_t>;
-                      }) {
-          return generic_post_header<code>::get_size_in_bytes(version);
-        } else {
-          return generic_post_header<code>::size_in_bytes;
-        }
-      });
-
-  constexpr auto hardcoded_post_header_lengths_generator{
-      []<std::size_t... IndexPack>(std::uint32_t version,
-                                   std::index_sequence<IndexPack...>) constexpr
-          -> post_header_length_container {
-        return {
-          static_cast<encoded_post_header_length_type>(
-              size_in_bytes_helper{}.template operator()<IndexPack>(version))...
-        };
-      }};
-
-  // the remainder of the 'earliest_supported_post_header_lengths' container
-  // will be default-initialized
-  static constexpr post_header_length_container
-      earliest_supported_post_header_lengths{
-          hardcoded_post_header_lengths_generator(
-              earliest_supported_protocol_server_version,
-              std::make_index_sequence<
-                  get_number_of_events(
-                      earliest_supported_protocol_server_version) -
-                  1U>{})};
-  static constexpr post_header_length_container
-      latest_known_post_header_lengths{hardcoded_post_header_lengths_generator(
-          latest_known_protocol_server_version,
-          std::make_index_sequence<get_number_of_events(
-                                       latest_known_protocol_server_version) -
-                                   1U>{})};
-
-  return encoded_server_version < latest_known_protocol_server_version
-             ? earliest_supported_post_header_lengths
-             : latest_known_post_header_lengths;
-}
-
 } // namespace binsrv::events
diff --git a/src/binsrv/events/reader_context.hpp b/src/binsrv/events/reader_context.hpp
index 6cdbbfe..8f3f23b 100644
--- a/src/binsrv/events/reader_context.hpp
+++ b/src/binsrv/events/reader_context.hpp
@@ -69,6 +69,10 @@ class [[nodiscard]] reader_context {
     return info_only_event_;
   }
 
+  [[nodiscard]] static const post_header_length_container &
+  get_hardcoded_post_header_lengths(
+      std::uint32_t encoded_server_version) noexcept;
+
 private:
   // this class implements the logic of the following state machine
   // (
@@ -130,10 +134,6 @@ class [[nodiscard]] reader_context {
   void start_transaction(const event &current_event);
   void update_transaction(const common_header &common_header);
   void finish_transaction();
-
-  [[nodiscard]] static const post_header_length_container &
-  get_hardcoded_post_header_lengths(
-      std::uint32_t encoded_server_version) noexcept;
 };
 
 } // namespace binsrv::events
diff --git a/src/binsrv/events/rotate_body_impl.cpp b/src/binsrv/events/rotate_body_impl.cpp
index 9329792..534d4b2 100644
--- a/src/binsrv/events/rotate_body_impl.cpp
+++ b/src/binsrv/events/rotate_body_impl.cpp
@@ -15,15 +15,24 @@
 
 #include "binsrv/events/rotate_body_impl.hpp"
 
+#include <algorithm>
 #include <iterator>
 #include <ostream>
+#include <stdexcept>
+#include <string_view>
 
 #include "binsrv/events/code_type.hpp"
 
 #include "util/byte_span.hpp"
+#include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
 
+generic_body_impl<code_type::rotate>::generic_body_impl(
+    std::string_view binlog_name)
+    : binlog_(std::cbegin(util::as_const_byte_span(binlog_name)),
+              std::cend(util::as_const_byte_span(binlog_name))) {}
+
 generic_body_impl<code_type::rotate>::generic_body_impl(
     util::const_byte_span portion) {
   // TODO: rework with direct member initialization
@@ -31,7 +40,17 @@ generic_body_impl<code_type::rotate>::generic_body_impl(
   // no need to check if member reordering is OK as this class has
   // only one member for holding data of varying length
 
-  binlog_.assign(std::begin(portion), std::end(portion));
+  binlog_.assign(std::cbegin(portion), std::cend(portion));
+}
+
+void generic_body_impl<code_type::rotate>::encode_to(
+    util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode rotate event body");
+  }
+  std::ranges::copy(binlog_, std::begin(destination));
+  destination = destination.subspan(calculate_encoded_size());
 }
 
 std::ostream &operator<<(std::ostream &output,
diff --git a/src/binsrv/events/rotate_body_impl.hpp b/src/binsrv/events/rotate_body_impl.hpp
index cb8b23a..5ecba8d 100644
--- a/src/binsrv/events/rotate_body_impl.hpp
+++ b/src/binsrv/events/rotate_body_impl.hpp
@@ -35,6 +35,7 @@ template <> class [[nodiscard]] generic_body_impl<code_type::rotate> {
       boost::container::small_vector<std::byte,
                                      expected_max_binlog_name_length>;
 
+  explicit generic_body_impl(std::string_view binlog_name);
   explicit generic_body_impl(util::const_byte_span portion);
 
   [[nodiscard]] const binlog_storage &get_binlog_raw() noexcept {
@@ -45,6 +46,14 @@ template <> class [[nodiscard]] generic_body_impl<code_type::rotate> {
     return util::as_string_view(binlog_);
   }
 
+  [[nodiscard]] std::size_t calculate_encoded_size() const noexcept {
+    return std::size(binlog_);
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const generic_body_impl &first,
+                         const generic_body_impl &second) = default;
+
 private:
   binlog_storage binlog_{};
 };
diff --git a/src/binsrv/events/rotate_post_header_impl.cpp b/src/binsrv/events/rotate_post_header_impl.cpp
index f431e9e..11722f7 100644
--- a/src/binsrv/events/rotate_post_header_impl.cpp
+++ b/src/binsrv/events/rotate_post_header_impl.cpp
@@ -25,6 +25,7 @@
 
 #include "util/byte_span.hpp"
 #include "util/byte_span_extractors.hpp"
+#include "util/byte_span_inserters.hpp"
 #include "util/exception_location_helpers.hpp"
 
 namespace binsrv::events {
@@ -67,13 +68,22 @@ generic_post_header_impl<code_type::rotate>::generic_post_header_impl(
 
   if (std::size(portion) != size_in_bytes) {
     util::exception_location().raise<std::invalid_argument>(
-        "invalid rotate event post-header length");
+        "invalid rotate event post header length");
   }
 
   auto remainder = portion;
   util::extract_fixed_int_from_byte_span(remainder, position_);
 }
 
+void generic_post_header_impl<code_type::rotate>::encode_to(
+    util::byte_span &destination) const {
+  if (std::size(destination) < calculate_encoded_size()) {
+    util::exception_location().raise<std::invalid_argument>(
+        "cannot encode rotate event post header");
+  }
+  util::insert_fixed_int_to_byte_span(destination, position_);
+}
+
 std::ostream &
 operator<<(std::ostream &output,
            const generic_post_header_impl<code_type::rotate> &obj) {
diff --git a/src/binsrv/events/rotate_post_header_impl.hpp b/src/binsrv/events/rotate_post_header_impl.hpp
index 4bd8239..2b57279 100644
--- a/src/binsrv/events/rotate_post_header_impl.hpp
+++ b/src/binsrv/events/rotate_post_header_impl.hpp
@@ -29,12 +29,22 @@ template <> class [[nodiscard]] generic_post_header_impl<code_type::rotate> {
 public:
   static constexpr std::size_t size_in_bytes{8U};
 
+  explicit generic_post_header_impl(std::uint64_t position) noexcept
+      : position_{position} {}
   explicit generic_post_header_impl(util::const_byte_span portion);
 
   [[nodiscard]] std::uint64_t get_position_raw() const noexcept {
     return position_;
   }
 
+  [[nodiscard]] static std::size_t calculate_encoded_size() noexcept {
+    return size_in_bytes;
+  }
+  void encode_to(util::byte_span &destination) const;
+
+  friend bool operator==(const generic_post_header_impl &first,
+                         const generic_post_header_impl &second) = default;
+
 private:
   std::uint64_t position_{};
 };
diff --git a/src/binsrv/events/unknown_body.hpp b/src/binsrv/events/unknown_body.hpp
index 8926dc6..912d0ab 100644
--- a/src/binsrv/events/unknown_body.hpp
+++ b/src/binsrv/events/unknown_body.hpp
@@ -28,6 +28,9 @@ class [[nodiscard]] unknown_body {
   // so it needs to be default constructible
   unknown_body() noexcept = default;
   explicit unknown_body(util::const_byte_span /*unused*/) noexcept {}
+
+  friend bool operator==(const unknown_body & /* first */,
+                         const unknown_body & /* second */) = default;
 };
 
 } // namespace binsrv::events
diff --git a/src/binsrv/events/unknown_post_header.hpp b/src/binsrv/events/unknown_post_header.hpp
index b15f351..ce4212f 100644
--- a/src/binsrv/events/unknown_post_header.hpp
+++ b/src/binsrv/events/unknown_post_header.hpp
@@ -34,6 +34,9 @@ class [[nodiscard]] unknown_post_header {
   // variant, so it needs to be default constructible
   unknown_post_header() noexcept = default;
   explicit unknown_post_header(util::const_byte_span /*unused*/) noexcept {}
+
+  friend bool operator==(const unknown_post_header & /* first */,
+                         const unknown_post_header & /* second */) = default;
 };
 
 } // namespace binsrv::events
diff --git a/src/binsrv/gtids/gtid_set.cpp b/src/binsrv/gtids/gtid_set.cpp
index b3107ec..e95de5a 100644
--- a/src/binsrv/gtids/gtid_set.cpp
+++ b/src/binsrv/gtids/gtid_set.cpp
@@ -30,7 +30,6 @@
 #include <stdexcept>
 #include <string>
 #include <string_view>
-#include <type_traits>
 #include <utility>
 
 #include <boost/icl/concept/interval.hpp>
@@ -46,6 +45,7 @@
 #include "util/byte_span_extractors.hpp"
 #include "util/byte_span_fwd.hpp"
 #include "util/byte_span_inserters.hpp"
+#include "util/conversion_helpers.hpp"
 #include "util/exception_location_helpers.hpp"
 
 namespace binsrv::gtids {
@@ -111,10 +111,8 @@ class gtid_set_parser {
   template <typename T>
   [[nodiscard]] static T char_to_value(char character, char base,
                                        T shift = T{}) noexcept {
-    using default_unsigned = std::make_unsigned_t<decltype(character - base)>;
-    return static_cast<T>(
-        static_cast<T>(static_cast<default_unsigned>(character - base)) +
-        shift);
+    return static_cast<T>(static_cast<T>(util::to_unsigned(character - base)) +
+                          shift);
   }
 
   // <hexadecimal> ::= [a-fA-F0-9]
@@ -145,8 +143,7 @@ class gtid_set_parser {
     std::uint8_t result{parse_hexadecimal(remainder)};
     result <<= 4U;
     result |= parse_hexadecimal(remainder);
-    using underlying_byte_type = std::underlying_type_t<std::byte>;
-    return static_cast<std::byte>(static_cast<underlying_byte_type>(result));
+    return util::from_underlying<std::byte>(result);
   }
 
   // <uuid> ::= <hexadecimal_pair>{4} '-' <hexadecimal_pair>{2} '-'
@@ -182,19 +179,17 @@ class gtid_set_parser {
 
   // <tag> ::= [a-zA-Z_][a-zA-Z0-9_]{0,31}
   [[nodiscard]] static tag parse_tag(std::string_view &remainder) {
-    using underlying_byte_type = std::underlying_type_t<std::byte>;
-
     tag_storage buffer{};
     char tag_character{util::parse_character_predicate(
         remainder, tag_first_character_predicate)};
-    buffer.push_back(static_cast<std::byte>(
-        static_cast<underlying_byte_type>(tag_character)));
+    buffer.push_back(
+        util::from_underlying<std::byte>(util::to_unsigned(tag_character)));
 
     while (std::size(buffer) < tag_max_length &&
            util::parse_character_predicate_ex(
                remainder, tag_other_characters_predicate, tag_character)) {
-      buffer.push_back(static_cast<std::byte>(
-          static_cast<underlying_byte_type>(tag_character)));
+      buffer.push_back(
+          util::from_underlying<std::byte>(util::to_unsigned(tag_character)));
     }
     assert(std::size(buffer) <= tag_max_length);
 
diff --git a/src/binsrv/gtids/uuid.cpp b/src/binsrv/gtids/uuid.cpp
index 91034c1..ffdf172 100644
--- a/src/binsrv/gtids/uuid.cpp
+++ b/src/binsrv/gtids/uuid.cpp
@@ -62,7 +62,7 @@ uuid::uuid(const uuid_storage &data) {
 void uuid::encode_to(util::byte_span &destination) const {
   const util::const_byte_span data_span{
       // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-      reinterpret_cast<const std::byte *>(std::begin(data_)),
+      reinterpret_cast<const std::byte *>(std::cbegin(data_)),
       boost::uuids::uuid::static_size()};
   if (!util::insert_byte_span_to_byte_span_checked(destination, data_span)) {
     util::exception_location().raise<std::invalid_argument>(
diff --git a/src/binsrv/s3_error_helpers_private.cpp b/src/binsrv/s3_error_helpers_private.cpp
index c9bea5d..9ac9cb6 100644
--- a/src/binsrv/s3_error_helpers_private.cpp
+++ b/src/binsrv/s3_error_helpers_private.cpp
@@ -18,12 +18,12 @@
 #include <source_location>
 #include <string>
 #include <string_view>
-#include <type_traits>
 
 #include <aws/s3-crt/S3CrtErrors.h>
 
 #include "binsrv/s3_error.hpp"
 
+#include "util/conversion_helpers.hpp"
 #include "util/exception_location_helpers.hpp"
 
 namespace binsrv {
@@ -49,9 +49,7 @@ raise_s3_error_from_outcome(std::string_view user_message,
   message += ", ResponseCode ";
   // TODO: in c++23 change to std::to_underlying()
   auto http_status_code = sdk_error.GetResponseCode();
-  message += std::to_string(
-      static_cast<std::underlying_type_t<decltype(http_status_code)>>(
-          http_status_code));
+  message += std::to_string(util::to_underlying(http_status_code));
   message += ')';
 
   // default value std::source_location::current() for the 'location'
diff --git a/src/binsrv/s3_storage_backend.cpp b/src/binsrv/s3_storage_backend.cpp
index 45986fb..bcfa1cc 100644
--- a/src/binsrv/s3_storage_backend.cpp
+++ b/src/binsrv/s3_storage_backend.cpp
@@ -614,19 +614,19 @@ void s3_storage_backend::init_with_endpoint(
   // As the result, in the provided storage URI configuration parameter we
   // consider its first path segment a buckedt name.
   const std::filesystem::path uri_path{uri.path()};
-  auto uri_path_it{std::begin(uri_path)};
-  assert(uri_path_it != std::end(uri_path));
+  auto uri_path_it{std::cbegin(uri_path)};
+  assert(uri_path_it != std::cend(uri_path));
   assert(*uri_path_it == "/");
   root_path_.assign(*uri_path_it);
   ++uri_path_it;
 
-  if (uri_path_it == std::end(uri_path)) {
+  if (uri_path_it == std::cend(uri_path)) {
     util::exception_location().raise<std::invalid_argument>(
         "endpoint s3 URI path must include at least on segment");
   }
   bucket_ = *uri_path_it;
   ++uri_path_it;
-  for (; uri_path_it != std::end(uri_path); ++uri_path_it) {
+  for (; uri_path_it != std::cend(uri_path); ++uri_path_it) {
     root_path_ /= *uri_path_it;
   }
 
diff --git a/src/binsrv/storage.cpp b/src/binsrv/storage.cpp
index b285e5c..c82255a 100644
--- a/src/binsrv/storage.cpp
+++ b/src/binsrv/storage.cpp
@@ -72,8 +72,8 @@ storage::storage(const storage_config &config,
     return;
   }
 
-  const auto metadata_it{storage_objects.find(metadata_name)};
-  if (metadata_it == std::end(storage_objects)) {
+  const auto metadata_it{std::as_const(storage_objects).find(metadata_name)};
+  if (metadata_it == std::cend(storage_objects)) {
     util::exception_location().raise<std::logic_error>(
         "storage is not empty but does not contain metadata");
   }
@@ -83,7 +83,7 @@ storage::storage(const storage_config &config,
   validate_metadata(replication_mode);
 
   const auto binlog_index_it{storage_objects.find(default_binlog_index_name)};
-  if (binlog_index_it == std::end(storage_objects)) {
+  if (binlog_index_it == std::cend(storage_objects)) {
     util::exception_location().raise<std::logic_error>(
         "storage is not empty but does not contain binlog index");
   }
@@ -91,8 +91,8 @@ storage::storage(const storage_config &config,
 
   // extracting all binlog file metadata files into a separate container
   storage_object_name_container storage_metadata_objects;
-  for (auto storage_object_it{std::begin(storage_objects)};
-       storage_object_it != std::end(storage_objects);) {
+  for (auto storage_object_it{std::cbegin(storage_objects)};
+       storage_object_it != std::cend(storage_objects);) {
     const std::filesystem::path object_name{storage_object_it->first};
     if (object_name.has_extension() &&
         object_name.extension() == binlog_metadata_extension) {
@@ -157,8 +157,8 @@ storage::open_binlog(std::string_view binlog_name) {
   // "binlog_records_", or we open an existing one and append to it, in which
   // case we need to make sure that the current position is properly set
   const bool binlog_exists{
-      std::ranges::find(binlog_records_, binlog_name, &binlog_record::name) !=
-      std::end(binlog_records_)};
+      std::ranges::find(std::as_const(binlog_records_), binlog_name,
+                        &binlog_record::name) != std::cend(binlog_records_)};
 
   // in the case when binlog exists, the name must be equal to the last item in
   // "binlog_records_" list and "position_" must be set to a non-zero value
@@ -351,7 +351,7 @@ void storage::flush_event_buffer_internal() {
 
   save_binlog_metadata(get_current_binlog_record());
 
-  const auto begin_it{std::begin(event_buffer_)};
+  const auto begin_it{std::cbegin(event_buffer_)};
   const auto portion_it{std::next(
       begin_it, static_cast<std::ptrdiff_t>(
                     last_transaction_boundary_position_in_event_buffer_))};
@@ -390,8 +390,8 @@ void storage::load_binlog_index() {
           "binlog index contains a reference to a binlog with invalid "
           "name");
     }
-    if (std::ranges::find(binlog_records_, current_binlog_name,
-                          &binlog_record::name) != std::end(binlog_records_)) {
+    if (std::ranges::find(std::as_const(binlog_records_), current_binlog_name,
+                          &binlog_record::name) != std::cend(binlog_records_)) {
       util::exception_location().raise<std::logic_error>(
           "binlog index contains a duplicate entry");
     }
diff --git a/src/util/byte_span_extractors.hpp b/src/util/byte_span_extractors.hpp
index f6f9864..686a908 100644
--- a/src/util/byte_span_extractors.hpp
+++ b/src/util/byte_span_extractors.hpp
@@ -28,6 +28,7 @@
 
 #include "util/byte_span_fwd.hpp"
 #include "util/byte_span_packed_int_constants.hpp"
+#include "util/conversion_helpers.hpp"
 
 namespace util {
 
@@ -49,8 +50,7 @@ void extract_fixed_int_from_byte_span(
     value = boost::endian::little_to_native(value_in_network_format);
   } else {
     // TODO: in c++23 change use std::to_underlying(*std::data(remainder))
-    using underlying_type = std::underlying_type_t<std::byte>;
-    value = static_cast<T>(static_cast<underlying_type>(*std::data(remainder)));
+    value = static_cast<T>(util::to_underlying(*std::data(remainder)));
   }
   remainder = remainder.subspan(bytes_to_extract);
 }
diff --git a/src/util/byte_span_inserters.hpp b/src/util/byte_span_inserters.hpp
index bf64c47..1185cef 100644
--- a/src/util/byte_span_inserters.hpp
+++ b/src/util/byte_span_inserters.hpp
@@ -28,6 +28,7 @@
 
 #include "util/byte_span_fwd.hpp"
 #include "util/byte_span_packed_int_constants.hpp"
+#include "util/conversion_helpers.hpp"
 
 namespace util {
 
@@ -47,9 +48,7 @@ void insert_fixed_int_to_byte_span(
     std::memcpy(std::data(remainder), &value_in_network_format,
                 bytes_to_insert);
   } else {
-    using underlying_type = std::underlying_type_t<std::byte>;
-    *std::data(remainder) =
-        static_cast<std::byte>(static_cast<underlying_type>(value));
+    *std::data(remainder) = util::from_underlying<std::byte>(value);
   }
   remainder = remainder.subspan(bytes_to_insert);
 }
diff --git a/src/util/conversion_helpers.hpp b/src/util/conversion_helpers.hpp
index 13b310d..d2be4b8 100644
--- a/src/util/conversion_helpers.hpp
+++ b/src/util/conversion_helpers.hpp
@@ -30,22 +30,52 @@ template <std::integral To, std::integral From>
   }
 }
 
+// TODO: remove this function when switch to c++23 and use std::to_underlying
+//       instead
+template <typename EnumType>
+  requires std::is_enum_v<EnumType>
+[[nodiscard]] constexpr std::underlying_type_t<EnumType>
+to_underlying(EnumType enum_value) noexcept {
+  return static_cast<std::underlying_type_t<EnumType>>(enum_value);
+}
+
+template <typename EnumType>
+  requires std::is_enum_v<EnumType>
+[[nodiscard]] constexpr EnumType
+from_underlying(std::underlying_type_t<EnumType> value) noexcept {
+  return static_cast<EnumType>(value);
+}
+
 template <typename EnumType>
   requires(std::is_enum_v<EnumType> &&
-           std::is_unsigned_v<std::underlying_type_t<EnumType>>)
-[[nodiscard]] constexpr std::size_t enum_to_index(EnumType value) noexcept {
-  return static_cast<std::size_t>(
-      static_cast<std::underlying_type_t<EnumType>>(value));
+           std::is_unsigned_v<std::underlying_type_t<EnumType>> &&
+           sizeof(std::underlying_type_t<EnumType>) <= sizeof(std::size_t))
+[[nodiscard]] constexpr std::size_t
+enum_to_index(EnumType enum_value) noexcept {
+  return static_cast<std::size_t>(to_underlying(enum_value));
 }
 
 template <typename EnumType>
   requires(std::is_enum_v<EnumType> &&
-           std::is_unsigned_v<std::underlying_type_t<EnumType>>)
+           std::is_unsigned_v<std::underlying_type_t<EnumType>> &&
+           sizeof(std::underlying_type_t<EnumType>) <= sizeof(std::size_t))
 [[nodiscard]] constexpr EnumType index_to_enum(std::size_t value) noexcept {
-  return static_cast<EnumType>(
+  return from_underlying<EnumType>(
       static_cast<std::underlying_type_t<EnumType>>(value));
 }
 
+template <std::integral Type>
+[[nodiscard]] constexpr std::make_unsigned_t<Type>
+to_unsigned(Type value) noexcept {
+  return static_cast<std::make_unsigned_t<Type>>(value);
+}
+
+template <std::integral Type>
+[[nodiscard]] constexpr std::make_signed_t<Type>
+to_signed(Type value) noexcept {
+  return static_cast<std::make_signed_t<Type>>(value);
+}
+
 } // namespace util
 
 #endif // UTIL_CONVERSION_HELPERS_HPP
diff --git a/src/util/flag_set.hpp b/src/util/flag_set.hpp
index b917283..7dfba7c 100644
--- a/src/util/flag_set.hpp
+++ b/src/util/flag_set.hpp
@@ -27,7 +27,7 @@
 namespace util {
 
 template <typename E>
-  requires std::is_enum_v<E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
 class [[nodiscard]] flag_set {
 public:
   using element_type = E;
@@ -36,26 +36,25 @@ class [[nodiscard]] flag_set {
 
   flag_set() noexcept = default;
   explicit flag_set(underlying_type bits) noexcept : bits_{bits} {}
-  // deliberately allow implicit conversions
-  // NOLINTNEXTLINE(hicpp-explicit-conversions)
-  flag_set(element_type element) noexcept : bits_{element} {
+  explicit flag_set(element_type element) noexcept
+      : bits_{static_cast<underlying_type>(element)} {
     assert(std::has_single_bit(bits_));
   }
   [[nodiscard]] bool is_empty() const noexcept {
     return bits_ == underlying_type{};
   }
   [[nodiscard]] bool has_element(element_type element) const noexcept {
-    auto underlying = static_cast<underlying_type>(element);
+    auto underlying{static_cast<underlying_type>(element)};
     assert(std::has_single_bit(underlying));
     return (bits_ & underlying) != underlying_type{};
   }
   void set_element(element_type element) noexcept {
-    auto underlying = static_cast<underlying_type>(element);
+    auto underlying{static_cast<underlying_type>(element)};
     assert(std::has_single_bit(underlying));
-    bits_ &= underlying;
+    bits_ |= underlying;
   }
   void flip_element(element_type element) noexcept {
-    auto underlying = static_cast<underlying_type>(element);
+    auto underlying{static_cast<underlying_type>(element)};
     assert(std::has_single_bit(underlying));
     bits_ ^= underlying;
   }
@@ -66,46 +65,108 @@ class [[nodiscard]] flag_set {
     bits_ &= other.bits_;
     return *this;
   }
+  this_type &operator&=(element_type other) noexcept {
+    return *this &= this_type{other};
+  }
+
   this_type &operator|=(this_type other) noexcept {
     bits_ |= other.bits_;
     return *this;
   }
+  this_type &operator|=(element_type other) noexcept {
+    return *this |= this_type{other};
+  }
+
   this_type &operator^=(this_type other) noexcept {
     bits_ ^= other.bits_;
     return *this;
   }
+  this_type &operator^=(element_type other) noexcept {
+    return *this ^= this_type{other};
+  }
 
 private:
   underlying_type bits_;
 };
 
 template <typename E>
-  requires std::is_enum_v<E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
 [[nodiscard]] flag_set<E> operator|(flag_set<E> first,
                                     flag_set<E> second) noexcept {
-  auto res = first;
+  auto res{first};
+  res |= second;
+  return res;
+}
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator|(flag_set<E> first, E second) noexcept {
+  auto res{first};
+  res |= second;
+  return res;
+}
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator|(E first, flag_set<E> second) noexcept {
+  flag_set<E> res{first};
   res |= second;
   return res;
 }
 
 template <typename E>
-  requires std::is_enum_v<E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
 [[nodiscard]] flag_set<E> operator&(flag_set<E> first,
                                     flag_set<E> second) noexcept {
-  auto res = first;
+  auto res{first};
+  res &= second;
+  return res;
+}
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator&(flag_set<E> first, E second) noexcept {
+  auto res{first};
+  res &= second;
+  return res;
+}
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator&(E first, flag_set<E> second) noexcept {
+  flag_set<E> res{first};
   res &= second;
   return res;
 }
 
 template <typename E>
-  requires std::is_enum_v<E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator^(flag_set<E> first,
+                                    flag_set<E> second) noexcept {
+  auto res{first};
+  res ^= second;
+  return res;
+}
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator^(flag_set<E> first, E second) noexcept {
+  auto res{first};
+  res ^= second;
+  return res;
+}
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
+[[nodiscard]] flag_set<E> operator^(E first, flag_set<E> second) noexcept {
+  flag_set<E> res{first};
+  res ^= second;
+  return res;
+}
+
+template <typename E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
 [[nodiscard]] std::string to_string(flag_set<E> flags) {
-  auto bits = flags.get_bits();
-  auto mask = static_cast<decltype(bits)>(1U);
+  auto bits{flags.get_bits()};
+  auto mask{static_cast<decltype(bits)>(1U)};
   std::string res;
   for (std::size_t idx{0U}; idx < sizeof(bits) * CHAR_BIT; ++idx, mask <<= 1U) {
     if ((bits & mask) != 0U) {
-      const auto label = to_string_view(static_cast<E>(mask));
+      const auto label{to_string_view(static_cast<E>(mask))};
       if (!label.empty()) {
         if (!res.empty()) {
           res += " | ";
diff --git a/src/util/flag_set_fwd.hpp b/src/util/flag_set_fwd.hpp
index 98a931b..75a52ca 100644
--- a/src/util/flag_set_fwd.hpp
+++ b/src/util/flag_set_fwd.hpp
@@ -21,7 +21,7 @@
 namespace util {
 
 template <typename E>
-  requires std::is_enum_v<E>
+  requires std::is_enum_v<E> && std::is_unsigned_v<std::underlying_type_t<E>>
 class flag_set;
 
 } // namespace util
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b9ac7ba..0f3fbe9 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -47,6 +47,137 @@ set(gtid_set_source_files
   ${PROJECT_SOURCE_DIR}/src/binsrv/gtids/gtid_set.cpp
 )
 
+set(event_set_source_files
+  ${PROJECT_SOURCE_DIR}/src/binsrv/ctime_timestamp.cpp
+
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/anonymous_gtid_log_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/anonymous_gtid_log_body_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/anonymous_gtid_log_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/anonymous_gtid_log_post_header_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/checksum_algorithm_type_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/checksum_algorithm_type.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/code_type_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/code_type.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header_view_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header_view.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header_view.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header_flag_type_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/common_header_flag_type.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/empty_body_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/empty_body.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/empty_body.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/empty_post_header_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/empty_post_header.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/empty_post_header.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/event_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/event.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/event.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/event_view_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/event_view.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/event_view.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/footer_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/footer.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/footer.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/footer_view_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/footer_view.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/footer_view.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/format_description_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/format_description_body_impl.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/format_description_body_impl.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/format_description_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/format_description_post_header_impl.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/format_description_post_header_impl.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/generic_body_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/generic_body.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/generic_post_header_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/generic_post_header.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_flag_type_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_flag_type.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_body_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_body.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_body.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_body_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_post_header_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_post_header.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_post_header.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_log_post_header_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_tagged_log_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_tagged_log_body_impl.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_tagged_log_body_impl.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_tagged_log_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/gtid_tagged_log_post_header_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/previous_gtids_log_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/previous_gtids_log_body_impl.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/previous_gtids_log_body_impl.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/previous_gtids_log_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/previous_gtids_log_post_header_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/protocol_traits_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/protocol_traits.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/protocol_traits.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/reader_context_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/reader_context.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/reader_context.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/rotate_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/rotate_body_impl.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/rotate_body_impl.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/rotate_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/rotate_post_header_impl.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/rotate_post_header_impl.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/stop_body_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/stop_body_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/stop_post_header_impl_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/stop_post_header_impl.hpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/unknown_body_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/unknown_body.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/unknown_body.cpp
+
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/unknown_post_header_fwd.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/unknown_post_header.hpp
+  ${PROJECT_SOURCE_DIR}/src/binsrv/events/unknown_post_header.cpp
+
+
+  ${PROJECT_SOURCE_DIR}/src/util/semantic_version.cpp
+  ${PROJECT_SOURCE_DIR}/src/util/crc_helpers.cpp
+)
+
 add_executable(byte_span_encoding_test byte_span_encoding_test.cpp ${byte_span_encoding_source_files})
 target_include_directories(byte_span_encoding_test PRIVATE "${PROJECT_SOURCE_DIR}/src")
 target_link_libraries(byte_span_encoding_test
@@ -108,8 +239,22 @@ set_target_properties(gtid_set_test PROPERTIES
   CXX_EXTENSIONS NO
 )
 
+add_executable(event_test event_test.cpp ${uuid_source_files} ${tag_source_files} ${gtid_source_files} ${gtid_set_source_files} ${event_set_source_files})
+target_include_directories(event_test PRIVATE "${PROJECT_SOURCE_DIR}/src")
+target_link_libraries(event_test
+  PRIVATE
+    binlog_server_compiler_flags
+    Boost::unit_test_framework
+    ZLIB::ZLIB
+)
+set_target_properties(event_test PROPERTIES
+  CXX_STANDARD_REQUIRED YES
+  CXX_EXTENSIONS NO
+)
+
 add_test(NAME byte_span_encoding_test COMMAND byte_span_encoding_test)
 add_test(NAME uuid_test COMMAND uuid_test)
 add_test(NAME tag_test COMMAND tag_test)
 add_test(NAME gtid_test COMMAND gtid_test)
 add_test(NAME gtid_set_test COMMAND gtid_set_test)
+add_test(NAME event_test COMMAND event_test)
diff --git a/tests/event_test.cpp b/tests/event_test.cpp
new file mode 100644
index 0000000..71582dd
--- /dev/null
+++ b/tests/event_test.cpp
@@ -0,0 +1,128 @@
+// Copyright (c) 2023-2024 Percona and/or its affiliates.
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License, version 2.0,
+// as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License, version 2.0, for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
+
+#include <cstdint>
+#include <string_view>
+
+#define BOOST_TEST_MODULE EventTests
+// this include is needed as it provides the 'main()' function
+// NOLINTNEXTLINE(misc-include-cleaner)
+#include <boost/test/unit_test.hpp>
+
+#include <boost/test/unit_test_suite.hpp>
+
+#include <boost/test/tools/old/interface.hpp>
+
+#include "binsrv/ctime_timestamp.hpp"
+#include "binsrv/replication_mode_type.hpp"
+
+#include "binsrv/gtids/gtid_set.hpp"
+
+#include "binsrv/events/checksum_algorithm_type.hpp"
+#include "binsrv/events/code_type.hpp"
+#include "binsrv/events/common_header.hpp"
+#include "binsrv/events/common_header_flag_type.hpp"
+#include "binsrv/events/event.hpp"
+#include "binsrv/events/protocol_traits_fwd.hpp"
+#include "binsrv/events/reader_context.hpp"
+
+#include "util/byte_span_fwd.hpp"
+#include "util/semantic_version.hpp"
+
+static constexpr std::uint32_t default_server_id{42U};
+
+BOOST_AUTO_TEST_CASE(EventRoundTrip) {
+  const util::semantic_version server_version{"8.4.8"};
+  std::uint32_t offset{0U};
+  binsrv::events::reader_context context{server_version.get_encoded(), true,
+                                         binsrv::replication_mode_type::gtid,
+                                         "", offset};
+
+  binsrv::events::event_storage event_buffer;
+
+  // artificial ROTATE event
+  offset = 0U;
+  const binsrv::events::common_header_flag_set flags{
+      binsrv::events::common_header_flag_type::artificial};
+
+  const binsrv::events::generic_post_header<binsrv::events::code_type::rotate>
+      rotate_post_header{binsrv::events::magic_binlog_offset};
+  const binsrv::events::generic_body<binsrv::events::code_type::rotate>
+      rotate_body{"binlog.000001"};
+
+  const auto generated_rotate_event{
+      binsrv::events::event::create_event<binsrv::events::code_type::rotate>(
+          offset,
+          // artificial ROTATE event must include zero timestamp
+          binsrv::ctime_timestamp{}, default_server_id, flags,
+          rotate_post_header, rotate_body, true, event_buffer)};
+
+  const binsrv::events::event parsed_rotate_event{
+      context, util::const_byte_span{event_buffer}};
+
+  BOOST_CHECK_EQUAL(generated_rotate_event, parsed_rotate_event);
+
+  // FORMAT_DESCRIPTION event
+  offset = binsrv::events::magic_binlog_offset;
+  const binsrv::events::generic_post_header<
+      binsrv::events::code_type::format_description>
+      format_description_post_header{
+          binsrv::events::default_binlog_version, server_version,
+          binsrv::ctime_timestamp::now(),
+          binsrv::events::default_common_header_length,
+          binsrv::events::reader_context::get_hardcoded_post_header_lengths(
+              server_version.get_encoded())};
+  const binsrv::events::generic_body<
+      binsrv::events::code_type::format_description>
+      format_description_body{binsrv::events::checksum_algorithm_type::crc32};
+
+  const auto generated_format_description_event{
+      binsrv::events::event::create_event<
+          binsrv::events::code_type::format_description>(
+          offset, binsrv::ctime_timestamp::now(), default_server_id,
+          binsrv::events::common_header_flag_set{},
+          format_description_post_header, format_description_body, true,
+          event_buffer)};
+
+  const binsrv::events::event parsed_format_description_event{
+      context, util::const_byte_span{event_buffer}};
+
+  BOOST_CHECK_EQUAL(generated_format_description_event,
+                    parsed_format_description_event);
+
+  // PREVIOUS_GTIDS_LOG event
+  offset = generated_format_description_event.get_common_header()
+               .get_next_event_position_raw();
+  const binsrv::events::generic_post_header<
+      binsrv::events::code_type::previous_gtids_log>
+      previous_gtids_log_post_header{};
+  const binsrv::events::generic_body<
+      binsrv::events::code_type::previous_gtids_log>
+      previous_gtids_log_body{binsrv::gtids::gtid_set{
+          "11111111-aaaa-1111-aaaa-111111111111:1:3-5"}};
+  const auto generated_previous_gtids_log_event{
+      binsrv::events::event::create_event<
+          binsrv::events::code_type::previous_gtids_log>(
+          offset, binsrv::ctime_timestamp::now(), default_server_id,
+          binsrv::events::common_header_flag_set{},
+          previous_gtids_log_post_header, previous_gtids_log_body, true,
+          event_buffer)};
+
+  const binsrv::events::event parsed_previous_gtids_log_event{
+      context, util::const_byte_span{event_buffer}};
+
+  BOOST_CHECK_EQUAL(generated_previous_gtids_log_event,
+                    parsed_previous_gtids_log_event);
+}