diff --git a/.dockerignore b/.dockerignore
index d07c51f7..d8d4c498 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -9,6 +9,7 @@ LICENSE
 **/*secret.json
 data/log
 data/secret
+data/serialized
 !data/secret/secret_test.json
 monitoring
 resources
diff --git a/.github/workflows/ubuntu-monitoring.yml b/.github/workflows/ubuntu-special.yml
similarity index 85%
rename from .github/workflows/ubuntu-monitoring.yml
rename to .github/workflows/ubuntu-special.yml
index a0dc9091..d7554cff 100644
--- a/.github/workflows/ubuntu-monitoring.yml
+++ b/.github/workflows/ubuntu-special.yml
@@ -1,4 +1,4 @@
-name: Monitoring
+name: Special
 
 on:
   push:
@@ -7,14 +7,14 @@ on:
   pull_request:
 
 jobs:
-  ubuntu-monitoring-build:
-    name: Build on Ubuntu with monitoring support
+  ubuntu-special-build:
+    name: Build on Ubuntu with monitoring / protobuf support
     runs-on: ubuntu-latest
     strategy:
       matrix:
         compiler: [g++-11]
         buildmode: [Debug]
-        build-prometheus-from-source: [0, 1]
+        build-special-from-source: [0, 1]
 
     steps:
       - name: Checkout repository code
@@ -38,7 +38,7 @@ jobs:
           ninja
 
           sudo cmake --install .
-        if: matrix.build-prometheus-from-source == 0
+        if: matrix.build-special-from-source == 0
 
       - name: Create Build Environment
         run: cmake -E make_directory ${{github.workspace}}/build
@@ -46,7 +46,7 @@ jobs:
       - name: Configure CMake
         working-directory: ${{github.workspace}}/build
         shell: bash
-        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{matrix.buildmode}} -DCMAKE_CXX_COMPILER=${{matrix.compiler}} -DCCT_BUILD_PROMETHEUS_FROM_SRC=${{matrix.build-prometheus-from-source}} -GNinja
+        run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{matrix.buildmode}} -DCMAKE_CXX_COMPILER=${{matrix.compiler}} -DCCT_BUILD_PROMETHEUS_FROM_SRC=${{matrix.build-special-from-source}} -DCCT_ENABLE_PROTO=${{matrix.build-special-from-source}} -GNinja
 
       - name: Build
         working-directory: ${{github.workspace}}/build
diff --git a/.gitignore b/.gitignore
index 8c01a78d..0e8592b9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -66,6 +66,7 @@ cscope*
 data/cache
 data/log
 data/secret
+data/serialized
 data/static/exchangeconfig.json
 data/static/generalconfig.json
 monitoring/data/grafana/*
diff --git a/CMakeLists.txt b/CMakeLists.txt
index dc63a7a1..955d67bd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,6 +36,7 @@ option(CCT_ENABLE_TESTS "Build the unit tests" ${MAIN_PROJECT})
 option(CCT_BUILD_EXEC "Build an executable instead of a static library" ${MAIN_PROJECT})
 option(CCT_ENABLE_ASAN "Compile with AddressSanitizer" ${CCT_ASAN_BUILD})
 option(CCT_ENABLE_CLANG_TIDY "Compile with clang-tidy checks" OFF)
+option(CCT_ENABLE_PROTO "Compile with protobuf support (to export data to the outside world)" ON)
 option(CCT_BUILD_PROMETHEUS_FROM_SRC "Fetch and build from prometheus-cpp sources" OFF)
 
 set(CCT_DATA_DIR "${CMAKE_CURRENT_SOURCE_DIR}/data" CACHE PATH "Needed data directory for coincenter. Can also be overriden at runtime with this environment variable")
@@ -135,6 +136,34 @@ else()
   endif()
 endif()
 
+if(CCT_ENABLE_PROTO)
+  find_package(Protobuf CONFIG)
+  if(protobuf_FOUND)
+    message(STATUS "Linking with protobuf ${protobuf_VERSION}")
+  else()
+    set(PROTOBUF_VERSION v25.3)
+    if (MSVC)
+      # protobuf v25.0 does not compile yet with MSVC: https://github.com/protocolbuffers/protobuf/issues/14602
+      # set(PROTOBUF_VERSION v24.4)
+    endif()
+
+    message(STATUS "Compiling protobuf ${PROTOBUF_VERSION} from sources")
+    
+    set(protobuf_BUILD_TESTS OFF)
+    set(ABSL_PROPAGATE_CXX_STD ON)
+    
+    FetchContent_Declare(
+      protobuf
+      GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git
+      GIT_TAG ${PROTOBUF_VERSION}
+    )
+    FetchContent_MakeAvailable(protobuf)
+
+    include(${protobuf_SOURCE_DIR}/cmake/protobuf-generate.cmake)
+  
+  endif()
+endif()
+
 # Unit Tests
 
 #[[ Create an executable
@@ -250,13 +279,20 @@ if(CCT_ENABLE_PROMETHEUS)
   add_compile_definitions(CCT_ENABLE_PROMETHEUS)
 endif()
 
+if(CCT_ENABLE_PROTO)
+  add_compile_definitions(CCT_ENABLE_PROTO)
+  add_compile_definitions("CCT_PROTOBUF_VERSION=\"${PROTOBUF_VERSION}\"")
+endif()
+
 # Link to sub folders CMakeLists.txt, from the lowest level to the highest level for documentation
 # (beware of cyclic dependencies)
 add_subdirectory(src/tech)
 add_subdirectory(src/monitoring)
 add_subdirectory(src/http-request)
 add_subdirectory(src/objects)
+add_subdirectory(src/serialization)
 add_subdirectory(src/api-objects)
+add_subdirectory(src/trading)
 add_subdirectory(src/api)
 add_subdirectory(src/engine)
 add_subdirectory(src/main)
diff --git a/CONFIG.md b/CONFIG.md
index efba43e0..b2c031c0 100644
--- a/CONFIG.md
+++ b/CONFIG.md
@@ -150,6 +150,7 @@ Refer to the hardcoded default json example as a model in case of doubt.
 | *query*     | **updateFrequency.depositWallet**  | Duration string (ex: `1min`)                                                     | Minimum duration between two consecutive requests of deposit information (including wallet)                                                                                                                                                                                                                                                                                                                              |
 | *query*     | **updateFrequency.currencyInfo**   | Duration string (ex: `4h`)                                                       | Minimum duration between two consecutive requests of dynamic currency info retrieval on Bithumb only (used for place order)                                                                                                                                                                                                                                                                                              |
 | *query*     | **placeSimulateRealOrder**         | Boolean (`true` or `false`)                                                      | If `true`, in trade simulation mode (with `--sim`) exchanges which do not support simulated mode in place order will actually place a real order, with the following characteristics: <ul><li>trade strategy forced to `maker`</li><li>price will be changed to a maximum for a sell, to a minimum for a buy</li></ul> This will allow place of a 'real' order that cannot be matched in practice (if it is, lucky you!) |
+| *query*     | **marketDataSerialization**        | Boolean (`true` or `false`)                                                      | If `true` and `coincenter` is compiled with **protobuf** support, some market data will automatically be exported in the `data/serialization` directory (`orderbook` and `last-trades`) for a long term storage                                                                                                                                                                                                          |
 | *query*     | **multiTradeAllowedByDefault**     | Boolean (`true` or `false`)                                                      | If `true`, [multi-trade](README.md#multi-trade) will be allowed by default for `trade`, `buy` and `sell`. It can be overridden at command line level with `--no-multi-trade` and `--multi-trade`.                                                                                                                                                                                                                        |
 | *query*     | **validateApiKey**                 | Boolean (`true` or `false`)                                                      | If `true`, each loaded private key will be tested at start of the program. In case of a failure, it will be removed from the list of private accounts loaded by `coincenter`, so that later queries do not consider it instead of raising a runtime exception. The downside is that it will make an additional check that will make startup slower.                                                                      |  |
 | *tradefees* | **maker**                          | String as decimal number representing a percentage (for instance, "0.15")        | Trade fees occurring when a maker order is matched                                                                                                                                                                                                                                                                                                                                                                       |
diff --git a/Dockerfile b/Dockerfile
index 73202ad0..32dd1a6c 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -23,12 +23,14 @@ ARG BUILD_MODE=Release
 ARG BUILD_TEST=0
 ARG BUILD_ASAN=0
 ARG BUILD_WITH_PROMETHEUS=1
+ARG BUILD_WITH_PROTOBUF=1
 
 # Build and launch tests if any
 RUN cmake -DCMAKE_BUILD_TYPE=${BUILD_MODE} \
     -DCCT_ENABLE_TESTS=${BUILD_TEST} \
     -DCCT_ENABLE_ASAN=${BUILD_ASAN} \
     -DCCT_BUILD_PROMETHEUS_FROM_SRC=${BUILD_WITH_PROMETHEUS} \
+    -DCCT_ENABLE_PROTO=${BUILD_WITH_PROTOBUF} \
     -GNinja .. && \
     ninja && \
     if [ "$BUILD_TEST" = "1" -o "$BUILD_TEST" = "ON" ]; then \
diff --git a/alpine.Dockerfile b/alpine.Dockerfile
index b52cab0b..da56099f 100644
--- a/alpine.Dockerfile
+++ b/alpine.Dockerfile
@@ -2,7 +2,7 @@
 FROM alpine:3.19.1 AS build
 
 # Install base & build dependencies, needed certificates for curl to work with https
-RUN apk add --update --upgrade --no-cache g++ libc-dev curl-dev cmake ninja git ca-certificates
+RUN apk add --update --upgrade --no-cache g++ linux-headers libc-dev curl-dev cmake ninja git ca-certificates
 
 # Set default directory for application
 WORKDIR /app
@@ -18,12 +18,14 @@ ARG BUILD_MODE=Release
 ARG BUILD_TEST=0
 ARG BUILD_ASAN=0
 ARG BUILD_WITH_PROMETHEUS=1
+ARG BUILD_WITH_PROTOBUF=1
 
 # Build and launch tests if any
 RUN cmake -DCMAKE_BUILD_TYPE=${BUILD_MODE} \
     -DCCT_ENABLE_TESTS=${BUILD_TEST} \
     -DCCT_ENABLE_ASAN=${BUILD_ASAN} \
     -DCCT_BUILD_PROMETHEUS_FROM_SRC=${BUILD_WITH_PROMETHEUS} \
+    -DCCT_ENABLE_PROTO=${BUILD_WITH_PROTOBUF} \
     -GNinja .. && \
     ninja && \
     if [ "$BUILD_TEST" = "1" -o "$BUILD_TEST" = "ON" ]; then \
diff --git a/src/api-objects/include/closed-order.hpp b/src/api-objects/include/closed-order.hpp
new file mode 100644
index 00000000..0433f167
--- /dev/null
+++ b/src/api-objects/include/closed-order.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+#include <compare>
+#include <string_view>
+
+#include "cct_string.hpp"
+#include "cct_type_traits.hpp"
+#include "market.hpp"
+#include "monetaryamount.hpp"
+#include "orderid.hpp"
+#include "timedef.hpp"
+#include "tradeside.hpp"
+
+namespace cct {
+
+class ClosedOrder {
+ public:
+  ClosedOrder(const char *id, MonetaryAmount matchedVolume, MonetaryAmount price, TimePoint matchedTime, TradeSide side)
+      : ClosedOrder(OrderId(id), matchedVolume, price, matchedTime, side) {}
+
+  ClosedOrder(std::string_view id, MonetaryAmount matchedVolume, MonetaryAmount price, TimePoint matchedTime,
+              TradeSide side);
+
+  ClosedOrder(OrderId &&id, MonetaryAmount matchedVolume, MonetaryAmount price, TimePoint matchedTime, TradeSide side);
+
+  MonetaryAmount matchedVolume() const { return _matchedVolume; }
+  MonetaryAmount price() const { return _price; }
+
+  OrderId &id() { return _id; }
+  const OrderId &id() const { return _id; }
+
+  TimePoint matchedTime() const { return _matchedTime; }
+
+  TradeSide side() const { return _side; }
+
+  std::string_view sideStr() const;
+
+  string matchedTimeStr() const;
+
+  Market market() const { return Market(_matchedVolume.currencyCode(), _price.currencyCode()); }
+
+  std::strong_ordering operator<=>(const ClosedOrder &) const noexcept = default;
+
+  using trivially_relocatable = is_trivially_relocatable<OrderId>::type;
+
+ private:
+  TimePoint _matchedTime;
+  OrderId _id;  // exchange internal id, format specific to each exchange
+  MonetaryAmount _matchedVolume;
+  MonetaryAmount _price;
+  TradeSide _side;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/api-objects/include/exchangeprivateapitypes.hpp b/src/api-objects/include/exchangeprivateapitypes.hpp
index 3351fd76..32718b34 100644
--- a/src/api-objects/include/exchangeprivateapitypes.hpp
+++ b/src/api-objects/include/exchangeprivateapitypes.hpp
@@ -2,6 +2,7 @@
 
 #include "cct_flatset.hpp"
 #include "cct_vector.hpp"
+#include "closed-order.hpp"
 #include "deposit.hpp"
 #include "order.hpp"
 #include "tradedamounts.hpp"
@@ -17,6 +18,8 @@ using WithdrawsSet = FlatSet<Withdraw>;
 using Orders = vector<Order>;
 using OrdersSet = FlatSet<Order>;
 
+using ClosedOrders = vector<ClosedOrder>;
+
 using TradedAmountsVector = vector<TradedAmounts>;
 
 struct TradedAmountsVectorWithFinalAmount {
diff --git a/src/api-objects/include/exchangepublicapitypes.hpp b/src/api-objects/include/exchangepublicapitypes.hpp
index f1e28e2f..7b8d8eec 100644
--- a/src/api-objects/include/exchangepublicapitypes.hpp
+++ b/src/api-objects/include/exchangepublicapitypes.hpp
@@ -12,9 +12,12 @@
 #include "publictrade.hpp"
 
 namespace cct {
+
 using MarketSet = FlatSet<Market>;
 using MarketOrderBookMap = std::unordered_map<Market, MarketOrderBook>;
 using MarketPriceMap = std::unordered_map<Market, MonetaryAmount>;
 using MarketsPath = SmallVector<Market, 3>;
 using TradesVector = vector<PublicTrade>;
-}  // namespace cct
\ No newline at end of file
+using MarketOrderBookVector = vector<MarketOrderBook>;
+
+}  // namespace cct
diff --git a/src/api-objects/src/closed-order.cpp b/src/api-objects/src/closed-order.cpp
new file mode 100644
index 00000000..bcc472b2
--- /dev/null
+++ b/src/api-objects/src/closed-order.cpp
@@ -0,0 +1,25 @@
+#include "closed-order.hpp"
+
+#include <string_view>
+#include <utility>
+
+#include "cct_string.hpp"
+#include "monetaryamount.hpp"
+#include "timedef.hpp"
+#include "timestring.hpp"
+#include "tradeside.hpp"
+
+namespace cct {
+
+ClosedOrder::ClosedOrder(std::string_view id, MonetaryAmount matchedVolume, MonetaryAmount price, TimePoint matchedTime,
+                         TradeSide side)
+    : _matchedTime(matchedTime), _id(id), _matchedVolume(matchedVolume), _price(price), _side(side) {}
+
+ClosedOrder::ClosedOrder(string &&id, MonetaryAmount matchedVolume, MonetaryAmount price, TimePoint matchedTime,
+                         TradeSide side)
+    : _matchedTime(matchedTime), _id(std::move(id)), _matchedVolume(matchedVolume), _price(price), _side(side) {}
+
+std::string_view ClosedOrder::sideStr() const { return SideStr(_side); }
+
+string ClosedOrder::matchedTimeStr() const { return ToString(_matchedTime); }
+}  // namespace cct
\ No newline at end of file
diff --git a/src/api/interface/CMakeLists.txt b/src/api/interface/CMakeLists.txt
index a17d1968..df998a70 100644
--- a/src/api/interface/CMakeLists.txt
+++ b/src/api/interface/CMakeLists.txt
@@ -3,6 +3,7 @@ aux_source_directory(src API_INTERFACE_SRC)
 
 add_library(coincenter_api-interface STATIC ${API_INTERFACE_SRC})
 target_link_libraries(coincenter_api-interface PUBLIC coincenter_api-exchange)
+target_link_libraries(coincenter_api-interface PUBLIC coincenter_serialization)
 target_link_libraries(coincenter_api-interface PRIVATE coincenter_monitoring)
 
 target_include_directories(coincenter_api-interface PUBLIC include)
diff --git a/src/api/interface/include/exchange.hpp b/src/api/interface/include/exchange.hpp
index ba5510dd..a4725c23 100644
--- a/src/api/interface/include/exchange.hpp
+++ b/src/api/interface/include/exchange.hpp
@@ -1,7 +1,9 @@
 #pragma once
 
+#include <memory>
 #include <optional>
 #include <string_view>
+#include <type_traits>
 
 #include "cct_exception.hpp"
 #include "currencycode.hpp"
@@ -12,22 +14,30 @@
 #include "exchangeprivateapi.hpp"
 #include "exchangepublicapi.hpp"
 #include "exchangepublicapitypes.hpp"
+#include "market.hpp"
 #include "marketorderbook.hpp"
 #include "monetaryamount.hpp"
 #include "monetaryamountbycurrencyset.hpp"
+#include "time-window.hpp"
 
 namespace cct {
+
+class AbstractMarketDataDeserializer;
+class AbstractMarketDataSerializer;
+
 class Exchange {
  public:
   using ExchangePublic = api::ExchangePublic;
 
   /// Builds a Exchange without private exchange. All private requests will be forbidden.
-  Exchange(const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic);
+  Exchange(std::string_view dataDir, const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic);
 
   /// Build a Exchange with both private and public exchanges
-  Exchange(const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic,
+  Exchange(std::string_view dataDir, const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic,
            api::ExchangePrivate &exchangePrivate);
 
+  ~Exchange();
+
   std::string_view name() const { return _exchangePublic.name(); }
   std::string_view keyName() const { return apiPrivate().keyName(); }
 
@@ -86,16 +96,12 @@ class Exchange {
     return _exchangePublic.queryAllApproximatedOrderBooks(depth);
   }
 
-  MarketOrderBook queryOrderBook(Market mk, int depth = ExchangePublic::kDefaultDepth) {
-    return _exchangePublic.queryOrderBook(mk, depth);
-  }
+  MarketOrderBook queryOrderBook(Market mk, int depth = ExchangePublic::kDefaultDepth);
 
   MonetaryAmount queryLast24hVolume(Market mk) { return _exchangePublic.queryLast24hVolume(mk); }
 
   /// Retrieve an ordered vector of recent last trades
-  TradesVector queryLastTrades(Market mk, int nbTrades = ExchangePublic::kNbLastTradesDefault) {
-    return _exchangePublic.queryLastTrades(mk, nbTrades);
-  }
+  TradesVector queryLastTrades(Market mk, int nbTrades = ExchangePublic::kNbLastTradesDefault);
 
   /// Retrieve the last price of given market.
   MonetaryAmount queryLastPrice(Market mk) { return _exchangePublic.queryLastPrice(mk); }
@@ -108,11 +114,24 @@ class Exchange {
     return name() == exchangeName.name() && (!exchangeName.isKeyNameDefined() || keyName() == exchangeName.keyName());
   }
 
+  MarketSet pullAvailableMarketsForReplay(TimeWindow timeWindow);
+
+  TradesVector pullTradesForReplay(Market market, TimeWindow timeWindow);
+
+  MarketOrderBookVector pullMarketOrderBooksForReplay(Market market, TimeWindow timeWindow);
+
   void updateCacheFile() const;
 
+  using trivially_relocatable = std::true_type;
+
  private:
+  Exchange(std::string_view dataDir, const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic,
+           api::ExchangePrivate *pExchangePrivate);
+
   api::ExchangePublic &_exchangePublic;
   api::ExchangePrivate *_pExchangePrivate = nullptr;
   const ExchangeConfig &_exchangeConfig;
+  std::unique_ptr<AbstractMarketDataDeserializer> _marketDataDeserializerPtr;
+  std::unique_ptr<AbstractMarketDataSerializer> _marketDataSerializerPtr;
 };
 }  // namespace cct
diff --git a/src/api/interface/src/exchange.cpp b/src/api/interface/src/exchange.cpp
index b6ed7dd8..2f8ffc5b 100644
--- a/src/api/interface/src/exchange.cpp
+++ b/src/api/interface/src/exchange.cpp
@@ -1,6 +1,7 @@
 #include "exchange.hpp"
 
 #include <memory>
+#include <string_view>
 
 #include "cct_log.hpp"
 #include "currencycode.hpp"
@@ -8,17 +9,46 @@
 #include "exchangeconfig.hpp"
 #include "exchangeprivateapi.hpp"
 #include "exchangepublicapi.hpp"
+#include "exchangepublicapitypes.hpp"
+
+#ifdef CCT_ENABLE_PROTO
+#include "proto-market-data-deserializer.hpp"
+#include "proto-market-data-serializer.hpp"
+#else
+#include "dummy-market-data-deserializer.hpp"
+#include "dummy-market-data-serializer.hpp"
+#endif
 
 namespace cct {
 
-Exchange::Exchange(const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic,
+#ifdef CCT_ENABLE_PROTO
+using MarketDataDeserializer = ProtoMarketDataDeserializer;
+using MarketDataSerializer = ProtoMarketDataSerializer;
+#else
+using MarketDataDeserializer = DummyMarketDataDeserializer;
+using MarketDataSerializer = DummyMarketDataSerializer;
+#endif
+
+Exchange::Exchange(std::string_view dataDir, const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic,
                    api::ExchangePrivate &exchangePrivate)
+    : Exchange(dataDir, exchangeConfig, exchangePublic, std::addressof(exchangePrivate)) {}
+
+Exchange::Exchange(std::string_view dataDir, const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic)
+    : Exchange(dataDir, exchangeConfig, exchangePublic, nullptr) {}
+
+Exchange::Exchange(std::string_view dataDir, const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic,
+                   api::ExchangePrivate *pExchangePrivate)
     : _exchangePublic(exchangePublic),
-      _pExchangePrivate(std::addressof(exchangePrivate)),
-      _exchangeConfig(exchangeConfig) {}
+      _pExchangePrivate(pExchangePrivate),
+      _exchangeConfig(exchangeConfig),
+      _marketDataDeserializerPtr(_exchangeConfig.withMarketDataSerialization()
+                                     ? new MarketDataDeserializer(dataDir, exchangePublic.name())
+                                     : nullptr),
+      _marketDataSerializerPtr(_exchangeConfig.withMarketDataSerialization()
+                                   ? new MarketDataSerializer(dataDir, exchangePublic.name())
+                                   : nullptr) {}
 
-Exchange::Exchange(const ExchangeConfig &exchangeConfig, api::ExchangePublic &exchangePublic)
-    : _exchangePublic(exchangePublic), _exchangeConfig(exchangeConfig) {}
+Exchange::~Exchange() = default;  // declared here to have definition of ~MarketDataSerializer
 
 bool Exchange::canWithdraw(CurrencyCode currencyCode, const CurrencyExchangeFlatSet &currencyExchangeSet) const {
   if (_exchangeConfig.excludedCurrenciesWithdrawal().contains(currencyCode)) {
@@ -41,6 +71,47 @@ bool Exchange::canDeposit(CurrencyCode currencyCode, const CurrencyExchangeFlatS
   return lb->canDeposit();
 }
 
+MarketOrderBook Exchange::queryOrderBook(Market mk, int depth) {
+  auto marketOrderBook = _exchangePublic.queryOrderBook(mk, depth);
+  if (_marketDataSerializerPtr) {
+    _marketDataSerializerPtr->push(marketOrderBook);
+  }
+  return marketOrderBook;
+}
+
+/// Retrieve an ordered vector of recent last trades
+TradesVector Exchange::queryLastTrades(Market mk, int nbTrades) {
+  auto lastTrades = _exchangePublic.queryLastTrades(mk, nbTrades);
+  if (_marketDataSerializerPtr) {
+    _marketDataSerializerPtr->push(lastTrades);
+  }
+  return lastTrades;
+}
+
+MarketSet Exchange::pullAvailableMarketsForReplay(TimeWindow timeWindow) {
+  MarketSet ret;
+  if (_marketDataDeserializerPtr) {
+    ret = MarketSet(_marketDataDeserializerPtr->pullMarketOrderBooksMarkets(timeWindow));
+    const auto tradesMarkets = _marketDataDeserializerPtr->pullTradeMarkets(timeWindow);
+    ret.insert(tradesMarkets.begin(), tradesMarkets.end());
+  }
+  return ret;
+}
+
+TradesVector Exchange::pullTradesForReplay(Market market, TimeWindow timeWindow) {
+  if (_marketDataDeserializerPtr) {
+    return _marketDataDeserializerPtr->pullTrades(market, timeWindow);
+  }
+  return {};
+}
+
+MarketOrderBookVector Exchange::pullMarketOrderBooksForReplay(Market market, TimeWindow timeWindow) {
+  if (_marketDataDeserializerPtr) {
+    return _marketDataDeserializerPtr->pullMarketOrderBooks(market, timeWindow);
+  }
+  return {};
+}
+
 void Exchange::updateCacheFile() const {
   _exchangePublic.updateCacheFile();
   if (_pExchangePrivate != nullptr) {
diff --git a/src/api/interface/src/exchangepool.cpp b/src/api/interface/src/exchangepool.cpp
index 1d04d5ef..6886f76f 100644
--- a/src/api/interface/src/exchangepool.cpp
+++ b/src/api/interface/src/exchangepool.cpp
@@ -31,6 +31,7 @@ ExchangePool::ExchangePool(const CoincenterInfo& coincenterInfo, FiatConverter&
       _krakenPublic(_coincenterInfo, _fiatConverter, _commonAPI),
       _kucoinPublic(_coincenterInfo, _fiatConverter, _commonAPI),
       _upbitPublic(_coincenterInfo, _fiatConverter, _commonAPI) {
+  const auto dataDir = coincenterInfo.dataDir();
   for (std::string_view exchangeStr : kSupportedExchanges) {
     api::ExchangePublic* exchangePublic;
     if (exchangeStr == "binance") {
@@ -81,10 +82,10 @@ ExchangePool::ExchangePool(const CoincenterInfo& coincenterInfo, FiatConverter&
           }
         }
 
-        _exchanges.emplace_back(exchangeConfig, *exchangePublic, *exchangePrivate);
+        _exchanges.emplace_back(dataDir, exchangeConfig, *exchangePublic, *exchangePrivate);
       }
     } else {
-      _exchanges.emplace_back(exchangeConfig, *exchangePublic);
+      _exchanges.emplace_back(dataDir, exchangeConfig, *exchangePublic);
     }
   }
   _exchanges.shrink_to_fit();
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
index 3e5f241e..26a6a692 100644
--- a/src/engine/CMakeLists.txt
+++ b/src/engine/CMakeLists.txt
@@ -6,6 +6,7 @@ target_link_libraries(coincenter_engine PUBLIC coincenter_api-common)
 target_link_libraries(coincenter_engine PUBLIC coincenter_api-exchange)
 target_link_libraries(coincenter_engine PUBLIC coincenter_api-interface)
 target_link_libraries(coincenter_engine PUBLIC coincenter_objects)
+target_link_libraries(coincenter_engine PUBLIC coincenter_trading-common)
 target_include_directories(coincenter_engine PUBLIC include)
 
 add_unit_test(
diff --git a/src/engine/include/coincentercommand.hpp b/src/engine/include/coincentercommand.hpp
index fe736333..366dc7b6 100644
--- a/src/engine/include/coincentercommand.hpp
+++ b/src/engine/include/coincentercommand.hpp
@@ -12,6 +12,7 @@
 #include "market.hpp"
 #include "monetaryamount.hpp"
 #include "ordersconstraints.hpp"
+#include "timedef.hpp"
 #include "tradeoptions.hpp"
 #include "withdrawoptions.hpp"
 #include "withdrawsconstraints.hpp"
@@ -50,15 +51,14 @@ class CoincenterCommand {
   CoincenterCommand& setCur1(CurrencyCode cur1);
   CoincenterCommand& setCur2(CurrencyCode cur2);
 
+  CoincenterCommand& setDuration(Duration dur);
+
   CoincenterCommand& setPercentageAmount(bool value = true);
   CoincenterCommand& withBalanceInUse(bool value = true);
 
   bool isPublic() const;
   bool isPrivate() const { return !isPublic(); }
 
-  bool isReadOnly() const;
-  bool isWrite() const { return !isReadOnly(); }
-
   const ExchangeNames& exchangeNames() const { return _exchangeNames; }
 
   const OrdersConstraints& ordersConstraints() const { return std::get<OrdersConstraints>(_specialOptions); }
@@ -86,13 +86,16 @@ class CoincenterCommand {
   bool isPercentageAmount() const { return _isPercentageAmount; }
   bool withBalanceInUse() const { return _withBalanceInUse; }
 
+  Duration duration() const { return std::get<Duration>(_specialOptions); }
+
   bool operator==(const CoincenterCommand&) const noexcept = default;
 
   using trivially_relocatable = std::integral_constant<bool, is_trivially_relocatable_v<ExchangeNames> &&
                                                                  is_trivially_relocatable_v<OrdersConstraints>>::type;
 
  private:
-  using SpecialOptions = std::variant<OrdersConstraints, WithdrawsOrDepositsConstraints, TradeOptions, WithdrawOptions>;
+  using SpecialOptions =
+      std::variant<OrdersConstraints, WithdrawsOrDepositsConstraints, TradeOptions, WithdrawOptions, Duration>;
 
   ExchangeNames _exchangeNames;
   SpecialOptions _specialOptions;
diff --git a/src/engine/include/coincenteroptions.hpp b/src/engine/include/coincenteroptions.hpp
index 7a11cf91..86a6b252 100644
--- a/src/engine/include/coincenteroptions.hpp
+++ b/src/engine/include/coincenteroptions.hpp
@@ -95,6 +95,9 @@ class CoincenterCmdLineOptions {
 
   std::string_view lastTrades;
 
+  std::optional<std::string_view> replay;
+  std::optional<std::string_view> replayMarkets;
+
   CommandLineOptionalInt repeats;
   int nbLastTrades = api::ExchangePublic::kNbLastTradesDefault;
   int monitoringPort = CoincenterCmdLineOptionsDefinitions::kDefaultMonitoringPort;
diff --git a/src/engine/include/coincenteroptionsdef.hpp b/src/engine/include/coincenteroptionsdef.hpp
index 7aeaafcc..fd603482 100644
--- a/src/engine/include/coincenteroptionsdef.hpp
+++ b/src/engine/include/coincenteroptionsdef.hpp
@@ -309,14 +309,14 @@ struct CoincenterAllowedOptions : private CoincenterCmdLineOptionsDefinitions {
        &OptValueType::minAge},
       {{{"Private queries", 3902}, "--max-age", "<time>", "Only select withdraws with given maximum age."},
        &OptValueType::maxAge},
-      {{{"Trade", 4000}, "buy", "<amt cur[,exch1,...]>", kSmartBuy}, &OptValueType::buy},
-      {{{"Trade", 4000}, "sell", "<amt[%]cur[,exch1,...]>", kSmartSell}, &OptValueType::sell},
-      {{{"Trade", 4000},
+      {{{"Order", 4000}, "buy", "<amt cur[,exch1,...]>", kSmartBuy}, &OptValueType::buy},
+      {{{"Order", 4000}, "sell", "<amt[%]cur[,exch1,...]>", kSmartSell}, &OptValueType::sell},
+      {{{"Order", 4000},
         "sell-all",
         "<cur[,exch1,...]>",
         "Sell all available amount on matching exchanges (or all if none specified), behaving like sell option."},
        &OptValueType::sellAll},
-      {{{"Trade", 4000},
+      {{{"Order", 4000},
         "trade",
         "<amt[%]cur1-cur2[,exch1,...]>",
         "Trade from given start amount on a list of exchanges, "
@@ -325,20 +325,20 @@ struct CoincenterAllowedOptions : private CoincenterCmdLineOptionsDefinitions {
         "of available amount on matching exchanges will be traded.\n"
         "Orders will be placed prioritizing accounts with largest amounts, at limit price by default."},
        &OptValueType::trade},
-      {{{"Trade", 4000},
+      {{{"Order", 4000},
         "trade-all",
         "<cur1-cur2[,exch1,...]>",
         "Trade from available amount from given currency on a list of exchanges,"
         " or all that have some balance on cur1 if none provided\n"
         "Order will be placed at limit price by default"},
        &OptValueType::tradeAll},
-      {{{"Trade", 4010},
+      {{{"Order", 4010},
         "--async",
         "",
         "Asynchronous trade mode. Trade orders will be sent in fire and forget mode, not following their lifetime "
         "until either match or cancel occurs.\nThis option is not compatible with multi trade."},
        &OptValueType::async},
-      {{{"Trade", 4010},
+      {{{"Order", 4010},
         "--multi-trade",
         "",
         "Allow multi step trades for this command, overriding default configuration of config file.\n"
@@ -347,12 +347,12 @@ struct CoincenterAllowedOptions : private CoincenterCmdLineOptionsDefinitions {
         "step (for instance, the trade timeout is related to a single trade, not the series of all trades of a multi "
         "trade)."},
        &OptValueType::forceMultiTrade},
-      {{{"Trade", 4020},
+      {{{"Order", 4020},
         "--no-multi-trade",
         "",
         "Force deactivation of multi trade mode for all exchanges, overriding default configuration of config file."},
        &OptValueType::forceSingleTrade},
-      {{{"Trade", 4030},
+      {{{"Order", 4030},
         "--price",
         "<n|amt cur>",
         "Manually select trade price, supporting two flavors.\n"
@@ -362,22 +362,22 @@ struct CoincenterAllowedOptions : private CoincenterCmdLineOptionsDefinitions {
         "             Order price will not be continuously updated.\n"
         "This option is not compatible with '--strategy'"},
        &OptValueType::tradePrice},
-      {{{"Trade", 4030}, "--strategy", "<maker|nibble|taker>", kTradeStrategy}, &OptValueType::tradeStrategy},
-      {{{"Trade", 4030}, "--timeout", "<time>", kTradeTimeout}, &OptValueType::tradeTimeout},
-      {{{"Trade", 4030},
+      {{{"Order", 4030}, "--strategy", "<maker|nibble|taker>", kTradeStrategy}, &OptValueType::tradeStrategy},
+      {{{"Order", 4030}, "--timeout", "<time>", kTradeTimeout}, &OptValueType::tradeTimeout},
+      {{{"Order", 4030},
         "--timeout-cancel",
         "",
         "If after the timeout some amount is still not traded,\n"
         "force cancel the remaining order"},
        &OptValueType::tradeTimeoutCancel},
-      {{{"Trade", 4030},
+      {{{"Order", 4030},
         "--timeout-match",
         "",
         "If after the timeout some amount is still not traded,\n"
         "force match by placing a remaining order at market price"},
        &OptValueType::tradeTimeoutMatch},
-      {{{"Trade", 4030}, "--update-price", "<time>", kTradeUpdatePrice}, &OptValueType::tradeUpdatePrice},
-      {{{"Trade", 4030}, "--sim", "", kSimulationMode}, &OptValueType::tradeSim},
+      {{{"Order", 4030}, "--update-price", "<time>", kTradeUpdatePrice}, &OptValueType::tradeUpdatePrice},
+      {{{"Order", 4030}, "--sim", "", kSimulationMode}, &OptValueType::tradeSim},
       {{{"Tools", 5000}, "dust-sweeper", "<cur[,exch1,...]>", kDustSweeper}, &OptValueType::dustSweeper},
       {{{"Withdraw and deposit", 6000},
         "deposit-info",
@@ -405,6 +405,9 @@ struct CoincenterAllowedOptions : private CoincenterCmdLineOptionsDefinitions {
         "Prints withdraw fees for matching currency and exchanges."
         "Currency and exchanges are optional, if specified, output will be filtered to match them."},
        &OptValueType::withdrawFees},
+      {{{"Trading", 8000}, "replay-markets", "<algorithm-name>", "Print markets available for replay."},
+       &OptValueType::replayMarkets},
+      {{{"Trading", 8001}, "replay", "<algorithm-name>", "Replay an algorithm on saved data."}, &OptValueType::replay},
       {{{"Monitoring", 9000},
         "--monitoring",
         "",
diff --git a/src/engine/include/exchangesorchestrator.hpp b/src/engine/include/exchangesorchestrator.hpp
index e1753af5..c6a26985 100644
--- a/src/engine/include/exchangesorchestrator.hpp
+++ b/src/engine/include/exchangesorchestrator.hpp
@@ -4,9 +4,11 @@
 #include <span>
 
 #include "exchangeretriever.hpp"
+#include "market-trader-engine.hpp"
 #include "market.hpp"
 #include "queryresulttypes.hpp"
 #include "threadpool.hpp"
+#include "time-window.hpp"
 #include "withdrawoptions.hpp"
 
 namespace cct {
@@ -79,6 +81,11 @@ class ExchangesOrchestrator {
 
   MonetaryAmountPerExchange getLastPricePerExchange(Market mk, ExchangeNameSpan exchangeNames);
 
+  MarketsPerExchange pullAvailableMarketsForReplay(TimeWindow timeWindow, ExchangeNameSpan exchangeNames);
+
+  void traderConsume(Market market, TimeWindow timeWindow, std::span<MarketTraderEngine> marketTraderEngines,
+                     ExchangeNameSpan exchangeNames);
+
  private:
   ExchangeRetriever _exchangeRetriever;
   ThreadPool _threadPool;
diff --git a/src/engine/include/queryresulttypes.hpp b/src/engine/include/queryresulttypes.hpp
index 482831a2..daa95737 100644
--- a/src/engine/include/queryresulttypes.hpp
+++ b/src/engine/include/queryresulttypes.hpp
@@ -39,6 +39,8 @@ using MonetaryAmountByCurrencySetPerExchange =
 
 using TradesPerExchange = FixedCapacityVector<ExchangeWith<TradesVector>, kNbSupportedExchanges>;
 
+using MarketOrderBooksPerExchange = FixedCapacityVector<ExchangeWith<MarketOrderBookVector>, kNbSupportedExchanges>;
+
 using TradeResultPerExchange = SmallVector<ExchangeWith<TradeResult>, kTypicalNbPrivateAccounts>;
 
 using TradedAmountsVectorWithFinalAmountPerExchange =
@@ -65,4 +67,4 @@ using DeliveredWithdrawInfoWithExchanges = std::pair<std::array<const Exchange *
 using NbCancelledOrdersPerExchange = SmallVector<ExchangeWith<int>, kTypicalNbPrivateAccounts>;
 
 using ConversionPathPerExchange = FixedCapacityVector<ExchangeWith<MarketsPath>, kNbSupportedExchanges>;
-}  // namespace cct
\ No newline at end of file
+}  // namespace cct
diff --git a/src/engine/include/stringoptionparser.hpp b/src/engine/include/stringoptionparser.hpp
index e3a468f4..7f01a220 100644
--- a/src/engine/include/stringoptionparser.hpp
+++ b/src/engine/include/stringoptionparser.hpp
@@ -11,6 +11,7 @@
 #include "exchangename.hpp"
 #include "market.hpp"
 #include "monetaryamount.hpp"
+#include "timedef.hpp"
 
 namespace cct {
 class StringOptionParser {
@@ -28,6 +29,10 @@ class StringOptionParser {
   /// otherwise exception invalid_argument will be raised
   CurrencyCode parseCurrency(FieldIs fieldIs = FieldIs::kMandatory);
 
+  /// If FieldIs is kOptional and there is no duration, min duration will be returned.
+  /// otherwise exception invalid_argument will be raised
+  Duration parseDuration(FieldIs fieldIs = FieldIs::kMandatory);
+
   /// If FieldIs is kOptional and there is no market, default market will be returned.
   /// otherwise exception invalid_argument will be raised
   Market parseMarket(FieldIs fieldIs = FieldIs::kMandatory);
diff --git a/src/engine/src/coincenter.cpp b/src/engine/src/coincenter.cpp
index efc6f163..aa1fbf80 100644
--- a/src/engine/src/coincenter.cpp
+++ b/src/engine/src/coincenter.cpp
@@ -7,21 +7,26 @@
 #include <utility>
 
 #include "balanceoptions.hpp"
+#include "cct_const.hpp"
 #include "cct_exception.hpp"
+#include "cct_fixedcapacityvector.hpp"
 #include "cct_log.hpp"
 #include "coincentercommands.hpp"
 #include "coincentercommandtype.hpp"
 #include "coincenterinfo.hpp"
 #include "currencycode.hpp"
 #include "depositsconstraints.hpp"
+#include "dummy-market-trader.hpp"
 #include "exchangename.hpp"
 #include "exchangeretriever.hpp"
 #include "exchangesecretsinfo.hpp"
+#include "market-trader-engine.hpp"
 #include "market.hpp"
 #include "monetaryamount.hpp"
 #include "ordersconstraints.hpp"
 #include "queryresultprinter.hpp"
 #include "queryresulttypes.hpp"
+#include "time-window.hpp"
 #include "transferablecommandresult.hpp"
 #include "withdrawsconstraints.hpp"
 
@@ -215,6 +220,57 @@ TransferableCommandResultVector Coincenter::processCommand(
       _queryResultPrinter.printDustSweeper(dustSweeper(cmd.exchangeNames(), cmd.cur1()), cmd.cur1());
       break;
     }
+    case CoincenterCommandType::kReplay: {
+      const auto nowTime = Clock::now();
+      const TimeWindow timeWindow(nowTime - cmd.duration(), nowTime);
+      const auto marketsPerExchange =
+          _exchangesOrchestrator.pullAvailableMarketsForReplay(timeWindow, cmd.exchangeNames());
+      MarketSet allMarkets;
+      for (const auto &[exchange, markets] : marketsPerExchange) {
+        std::ranges::copy(markets, std::inserter(allMarkets, allMarkets.end()));
+      }
+
+      for (const Market market : allMarkets) {
+        FixedCapacityVector<ExchangeName, kNbSupportedExchanges> exchangesWithThisMarketData;
+        for (const auto &[exchange, markets] : marketsPerExchange) {
+          if (markets.contains(market)) {
+            exchangesWithThisMarketData.emplace_back(exchange->name());
+          }
+        }
+
+        const int nbExchanges = static_cast<int>(exchangesWithThisMarketData.size());
+
+        // TODO: could be configurable in general config
+        static constexpr auto kLoadGranularityDuration = std::chrono::weeks(1);
+
+        FixedCapacityVector<DummyMarketTrader, kNbSupportedExchanges> marketTraders(exchangesWithThisMarketData.size());
+        FixedCapacityVector<MarketTraderEngine, kNbSupportedExchanges> marketTraderEngines;
+        {
+          int exchangePos{};
+          for (const auto &exchangeName : exchangesWithThisMarketData) {
+            marketTraderEngines.emplace_back(market, marketTraders[exchangePos++]);
+          }
+        }
+
+        TimeWindow subTimeWindow(timeWindow.from(), timeWindow.from() + kLoadGranularityDuration);
+        while (subTimeWindow.overlap(timeWindow)) {
+          _exchangesOrchestrator.traderConsume(market, subTimeWindow, marketTraderEngines, exchangesWithThisMarketData);
+
+          // Go to next sub time window
+          subTimeWindow = TimeWindow(subTimeWindow.to(), subTimeWindow.to() + kLoadGranularityDuration);
+        }
+      }
+
+      break;
+    }
+    case CoincenterCommandType::kReplayMarkets: {
+      const auto nowTime = Clock::now();
+      const TimeWindow timeWindow(nowTime - cmd.duration(), nowTime);
+      const auto marketsPerExchange =
+          _exchangesOrchestrator.pullAvailableMarketsForReplay(timeWindow, cmd.exchangeNames());
+      _queryResultPrinter.printMarkets(CurrencyCode{}, CurrencyCode{}, marketsPerExchange);
+      break;
+    }
     default:
       throw exception("Unknown command type");
   }
diff --git a/src/engine/src/coincentercommand.cpp b/src/engine/src/coincentercommand.cpp
index d117618f..7ab8a488 100644
--- a/src/engine/src/coincentercommand.cpp
+++ b/src/engine/src/coincentercommand.cpp
@@ -10,6 +10,7 @@
 #include "market.hpp"
 #include "monetaryamount.hpp"
 #include "ordersconstraints.hpp"
+#include "timedef.hpp"
 #include "tradeoptions.hpp"
 #include "withdrawoptions.hpp"
 #include "withdrawsconstraints.hpp"
@@ -42,26 +43,6 @@ bool CoincenterCommand::isPublic() const {
   }
 }
 
-bool CoincenterCommand::isReadOnly() const {
-  if (isPublic()) {
-    return true;
-  }
-  switch (_type) {
-    case CoincenterCommandType::kBalance:  // NOLINT(bugprone-branch-clone)
-      [[fallthrough]];
-    case CoincenterCommandType::kDepositInfo:
-      [[fallthrough]];
-    case CoincenterCommandType::kRecentDeposits:
-      [[fallthrough]];
-    case CoincenterCommandType::kRecentWithdraws:
-      [[fallthrough]];
-    case CoincenterCommandType::kOrdersOpened:
-      return true;
-    default:
-      return false;
-  }
-}
-
 CoincenterCommand& CoincenterCommand::setExchangeNames(const ExchangeNames& exchangeNames) {
   _exchangeNames = exchangeNames;
   return *this;
@@ -197,4 +178,12 @@ CoincenterCommand& CoincenterCommand::withBalanceInUse(bool value) {
   _withBalanceInUse = value;
   return *this;
 }
+
+CoincenterCommand& CoincenterCommand::setDuration(Duration dur) {
+  if (dur != kUndefinedDuration) {
+    _specialOptions = dur;
+  }
+  return *this;
+}
+
 }  // namespace cct
\ No newline at end of file
diff --git a/src/engine/src/coincentercommands.cpp b/src/engine/src/coincentercommands.cpp
index e4b5dad7..05267245 100644
--- a/src/engine/src/coincentercommands.cpp
+++ b/src/engine/src/coincentercommands.cpp
@@ -176,6 +176,22 @@ void CoincenterCommands::addOption(const CoincenterCmdLineOptions &cmdLineOption
         .setExchangeNames(optionParser.parseExchanges());
   }
 
+  if (cmdLineOptions.replay) {
+    optionParser = StringOptionParser(*cmdLineOptions.replay);
+
+    _commands.emplace_back(CoincenterCommandType::kReplay)
+        .setDuration(optionParser.parseDuration(StringOptionParser::FieldIs::kOptional))
+        .setExchangeNames(optionParser.parseExchanges());
+  }
+
+  if (cmdLineOptions.replayMarkets) {
+    optionParser = StringOptionParser(*cmdLineOptions.replayMarkets);
+
+    _commands.emplace_back(CoincenterCommandType::kReplayMarkets)
+        .setDuration(optionParser.parseDuration(StringOptionParser::FieldIs::kOptional))
+        .setExchangeNames(optionParser.parseExchanges());
+  }
+
   optionParser.checkEndParsing();  // No more option part should be remaining
 }
 
diff --git a/src/engine/src/coincenteroptions.cpp b/src/engine/src/coincenteroptions.cpp
index 7871fee2..cf50b19d 100644
--- a/src/engine/src/coincenteroptions.cpp
+++ b/src/engine/src/coincenteroptions.cpp
@@ -37,6 +37,10 @@ std::ostream& CoincenterCmdLineOptions::PrintVersion(std::string_view programNam
   os << "compiled with " << CCT_COMPILER_VERSION << " on " << __DATE__ << " at " << __TIME__ << '\n';
   os << "              " << GetCurlVersionInfo() << '\n';
   os << "              " << ssl::GetOpenSSLVersion() << '\n';
+#ifdef CCT_PROTOBUF_VERSION
+  os << "              "
+     << "protobuf " << CCT_PROTOBUF_VERSION << '\n';
+#endif
   return os;
 }
 
diff --git a/src/engine/src/exchangesorchestrator.cpp b/src/engine/src/exchangesorchestrator.cpp
index b1c0539e..27422c5d 100644
--- a/src/engine/src/exchangesorchestrator.cpp
+++ b/src/engine/src/exchangesorchestrator.cpp
@@ -30,6 +30,7 @@
 #include "exchangepublicapitypes.hpp"
 #include "exchangeretriever.hpp"
 #include "exchangeretrieverbase.hpp"
+#include "market-trader-engine.hpp"
 #include "market.hpp"
 #include "marketorderbook.hpp"
 #include "monetaryamount.hpp"
@@ -867,4 +868,38 @@ MonetaryAmountPerExchange ExchangesOrchestrator::getLastPricePerExchange(Market
   return lastPricePerExchange;
 }
 
+MarketsPerExchange ExchangesOrchestrator::pullAvailableMarketsForReplay(TimeWindow timeWindow,
+                                                                        ExchangeNameSpan exchangeNames) {
+  log::info("Query available markets for replay from {} within {}", ConstructAccumulatedExchangeNames(exchangeNames),
+            timeWindow);
+  UniquePublicSelectedExchanges selectedExchanges = _exchangeRetriever.selectOneAccount(exchangeNames);
+  MarketsPerExchange marketsPerExchange(selectedExchanges.size());
+  _threadPool.parallelTransform(selectedExchanges.begin(), selectedExchanges.end(), marketsPerExchange.begin(),
+                                [timeWindow](Exchange *exchange) {
+                                  return std::make_pair(exchange, exchange->pullAvailableMarketsForReplay(timeWindow));
+                                });
+  return marketsPerExchange;
+}
+
+void ExchangesOrchestrator::traderConsume(Market market, TimeWindow timeWindow,
+                                          std::span<MarketTraderEngine> marketTraderEngines,
+                                          ExchangeNameSpan exchangeNames) {
+  UniquePublicSelectedExchanges selectedExchanges = _exchangeRetriever.selectOneAccount(exchangeNames);
+
+  using DummyOutput = FixedCapacityVector<int, kNbSupportedExchanges>;
+
+  DummyOutput dummyOutput(selectedExchanges.size());
+
+  _threadPool.parallelTransform(
+      selectedExchanges.begin(), selectedExchanges.end(), marketTraderEngines.begin(), dummyOutput.begin(),
+      [market, timeWindow](Exchange *exchange, MarketTraderEngine &marketTraderEngine) {
+        const auto marketOrderBookData = exchange->pullMarketOrderBooksForReplay(market, timeWindow);
+        const auto marketTradeData = exchange->pullTradesForReplay(market, timeWindow);
+
+        marketTraderEngine.trade(marketOrderBookData, marketTradeData);
+
+        return 0;  // TODO: cleanup or adapt if return value needed
+      });
+}
+
 }  // namespace cct
diff --git a/src/engine/src/stringoptionparser.cpp b/src/engine/src/stringoptionparser.cpp
index ba3c22ae..da96c81e 100644
--- a/src/engine/src/stringoptionparser.cpp
+++ b/src/engine/src/stringoptionparser.cpp
@@ -9,6 +9,7 @@
 #include "cct_string.hpp"
 #include "cct_vector.hpp"
 #include "currencycode.hpp"
+#include "durationstring.hpp"
 #include "exchangename.hpp"
 #include "market.hpp"
 #include "monetaryamount.hpp"
@@ -44,6 +45,7 @@ CurrencyCode StringOptionParser::parseCurrency(FieldIs fieldIs) {
   const auto begIt = _opt.begin() + _pos;
   const bool isCommaPresent = commaPos != std::string_view::npos;
   const std::string_view firstStr(begIt, isCommaPresent ? _opt.begin() + commaPos : _opt.end());
+
   std::string_view curStr;
   if (!firstStr.empty() && !ExchangeName::IsValid(firstStr) && CurrencyCode::IsValid(firstStr)) {
     // disambiguate currency code from exchange name
@@ -58,6 +60,23 @@ CurrencyCode StringOptionParser::parseCurrency(FieldIs fieldIs) {
   return curStr;
 }
 
+Duration StringOptionParser::parseDuration(FieldIs fieldIs) {
+  Duration dur = kUndefinedDuration;
+  const std::string_view currentToken(_opt.begin() + _pos, _opt.end());
+  const auto durationLen = DurationLen(currentToken);
+  if (durationLen > 0) {
+    const std::string_view durationStr(_opt.begin() + _pos, static_cast<std::size_t>(durationLen));
+
+    dur = ParseDuration(durationStr);
+  } else if (fieldIs == FieldIs::kMandatory) {
+    throw invalid_argument("Expected a valid duration in '{}'", currentToken);
+  }
+
+  _pos += durationLen;
+
+  return dur;
+}
+
 // At the end of the market, either the end of the string or a comma is expected.
 Market StringOptionParser::parseMarket(FieldIs fieldIs) {
   const std::size_t commaPos = _opt.find(',', _pos);
@@ -65,6 +84,7 @@ Market StringOptionParser::parseMarket(FieldIs fieldIs) {
   const bool isCommaPresent = commaPos != std::string_view::npos;
   const std::string_view marketStr(begIt, isCommaPresent ? begIt + commaPos : _opt.end());
   const std::size_t dashPos = marketStr.find('-');
+
   if (dashPos == std::string_view::npos) {
     if (fieldIs == FieldIs::kMandatory) {
       throw invalid_argument("Expected a dash in '{}'", std::string_view(_opt.begin() + _pos, _opt.end()));
@@ -180,10 +200,12 @@ ExchangeNames StringOptionParser::parseExchanges(char exchangesSep, char endExch
     std::size_t last = str.find(exchangesSep);
     for (; last != std::string_view::npos; last = str.find(exchangesSep, last + 1)) {
       std::string_view exchangeNameStr(str.begin() + first, str.begin() + last);
-      if (!ExchangeName::IsValid(exchangeNameStr)) {
-        return exchanges;
+      if (!exchangeNameStr.empty()) {
+        if (!ExchangeName::IsValid(exchangeNameStr)) {
+          return exchanges;
+        }
+        exchanges.emplace_back(exchangeNameStr);
       }
-      exchanges.emplace_back(exchangeNameStr);
       first = last + 1;
       _pos += exchangeNameStr.size() + 1U;
     }
diff --git a/src/engine/test/exchangedata_test.hpp b/src/engine/test/exchangedata_test.hpp
index 1fce20cd..75cc0de2 100644
--- a/src/engine/test/exchangedata_test.hpp
+++ b/src/engine/test/exchangedata_test.hpp
@@ -41,14 +41,22 @@ class ExchangesBaseTest : public ::testing::Test {
   api::MockExchangePrivate exchangePrivate6{exchangePublic3, coincenterInfo, key4};
   api::MockExchangePrivate exchangePrivate7{exchangePublic3, coincenterInfo, key5};
   api::MockExchangePrivate exchangePrivate8{exchangePublic1, coincenterInfo, key2};
-  Exchange exchange1{coincenterInfo.exchangeConfig(exchangePublic1.name()), exchangePublic1, exchangePrivate1};
-  Exchange exchange2{coincenterInfo.exchangeConfig(exchangePublic2.name()), exchangePublic2, exchangePrivate2};
-  Exchange exchange3{coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3, exchangePrivate3};
-  Exchange exchange4{coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3, exchangePrivate4};
-  Exchange exchange5{coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3, exchangePrivate5};
-  Exchange exchange6{coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3, exchangePrivate6};
-  Exchange exchange7{coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3, exchangePrivate7};
-  Exchange exchange8{coincenterInfo.exchangeConfig(exchangePublic1.name()), exchangePublic1, exchangePrivate8};
+  Exchange exchange1{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic1.name()), exchangePublic1,
+                     exchangePrivate1};
+  Exchange exchange2{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic2.name()), exchangePublic2,
+                     exchangePrivate2};
+  Exchange exchange3{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3,
+                     exchangePrivate3};
+  Exchange exchange4{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3,
+                     exchangePrivate4};
+  Exchange exchange5{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3,
+                     exchangePrivate5};
+  Exchange exchange6{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3,
+                     exchangePrivate6};
+  Exchange exchange7{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic3.name()), exchangePublic3,
+                     exchangePrivate7};
+  Exchange exchange8{kDefaultDataDir, coincenterInfo.exchangeConfig(exchangePublic1.name()), exchangePublic1,
+                     exchangePrivate8};
 
   static constexpr Market m1{"ETH", "EUR"};
   static constexpr Market m2{"BTC", "EUR"};
diff --git a/src/engine/test/stringoptionparser_test.cpp b/src/engine/test/stringoptionparser_test.cpp
index 72552477..731c6420 100644
--- a/src/engine/test/stringoptionparser_test.cpp
+++ b/src/engine/test/stringoptionparser_test.cpp
@@ -2,6 +2,7 @@
 
 #include <gtest/gtest.h>
 
+#include <chrono>
 #include <utility>
 
 #include "cct_invalid_argument_exception.hpp"
@@ -11,6 +12,7 @@
 #include "exchangename.hpp"
 #include "market.hpp"
 #include "monetaryamount.hpp"
+#include "timedef.hpp"
 
 namespace cct {
 namespace {
@@ -210,4 +212,26 @@ TEST(StringOptionParserTest, ExchangesNotLast) {
   EXPECT_NO_THROW(parser.checkEndParsing());
 }
 
+TEST(StringOptionParserTest, ParseDurationMandatory) {
+  StringOptionParser parser(" 45min83s,kraken,upbit");
+
+  EXPECT_EQ(parser.parseDuration(StringOptionParser::FieldIs::kMandatory),
+            std::chrono::minutes{45} + std::chrono::seconds{83});
+  EXPECT_EQ(parser.parseExchanges(',', '\0'), ExchangeNames({ExchangeName("kraken"), ExchangeName("upbit")}));
+
+  EXPECT_NO_THROW(parser.checkEndParsing());
+}
+
+TEST(StringOptionParserTest, ParseDurationOptional) {
+  StringOptionParser parser("binance,huobi_user1,34h 4500ms");
+
+  EXPECT_EQ(parser.parseDuration(StringOptionParser::FieldIs::kOptional), kUndefinedDuration);
+  EXPECT_EQ(parser.parseExchanges(',', '\0'), ExchangeNames({ExchangeName("binance"), ExchangeName("huobi", "user1")}));
+
+  EXPECT_EQ(parser.parseDuration(StringOptionParser::FieldIs::kOptional),
+            std::chrono::hours{34} + std::chrono::milliseconds{4500});
+
+  EXPECT_NO_THROW(parser.checkEndParsing());
+}
+
 }  // namespace cct
\ No newline at end of file
diff --git a/src/main/CMakeLists.txt b/src/main/CMakeLists.txt
index d97cde5b..56d9fc2c 100644
--- a/src/main/CMakeLists.txt
+++ b/src/main/CMakeLists.txt
@@ -15,6 +15,10 @@ endif()
 
 target_link_libraries(coincenter PUBLIC coincenter_engine)
 
+if(CCT_ENABLE_PROTO)
+  target_link_libraries(coincenter PUBLIC protobuf::libprotobuf)
+endif()
+
 set_target_properties(coincenter PROPERTIES
     VERSION ${PROJECT_VERSION}
     COMPILE_DEFINITIONS_DEBUG "JSON_DEBUG;JSON_SAFE;JSON_ISO_STRICT"
diff --git a/src/objects/include/coincentercommandtype.hpp b/src/objects/include/coincentercommandtype.hpp
index 5078ba1a..0ae00ca5 100644
--- a/src/objects/include/coincentercommandtype.hpp
+++ b/src/objects/include/coincentercommandtype.hpp
@@ -28,6 +28,9 @@ enum class CoincenterCommandType : int8_t {
   kWithdrawApply,
   kDustSweeper,
 
+  kReplay,
+  kReplayMarkets,
+
   kLast
 };
 
@@ -36,4 +39,4 @@ std::string_view CoincenterCommandTypeToString(CoincenterCommandType type);
 CoincenterCommandType CoincenterCommandTypeFromString(std::string_view str);
 
 bool IsAnyTrade(CoincenterCommandType type);
-}  // namespace cct
\ No newline at end of file
+}  // namespace cct
diff --git a/src/objects/include/exchangeconfig.hpp b/src/objects/include/exchangeconfig.hpp
index 6af42bf3..255dbc11 100644
--- a/src/objects/include/exchangeconfig.hpp
+++ b/src/objects/include/exchangeconfig.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <string_view>
 
 #include "apiquerytypeenum.hpp"
@@ -17,6 +18,7 @@ namespace cct {
 class ExchangeConfig {
  public:
   enum struct FeeType { kMaker, kTaker };
+  enum class MarketDataSerialization : int8_t { kYes, kNo };
 
   struct APIUpdateFrequencies {
     Duration freq[api::kQueryTypeMax];
@@ -29,7 +31,7 @@ class ExchangeConfig {
                  std::string_view acceptEncoding, int dustSweeperMaxNbTrades,
                  log::level::level_enum requestsCallLogLevel, log::level::level_enum requestsAnswerLogLevel,
                  bool multiTradeAllowedByDefault, bool validateDepositAddressesInFile, bool placeSimulateRealOrder,
-                 bool validateApiKey, TradeConfig tradeConfig);
+                 bool validateApiKey, TradeConfig tradeConfig, MarketDataSerialization marketDataSerialization);
 
   /// Get a reference to the list of statically excluded currency codes to consider for the exchange,
   /// In both trading and withdrawal.
@@ -98,6 +100,8 @@ class ExchangeConfig {
 
   const TradeConfig &tradeConfig() const { return _tradeConfig; }
 
+  bool withMarketDataSerialization() const { return _withMarketSerialization; }
+
  private:
   CurrencyCodeSet _excludedCurrenciesAll;             // Currencies will be completely ignored by the exchange
   CurrencyCodeSet _excludedCurrenciesWithdrawal;      // Currencies unavailable for withdrawals
@@ -118,5 +122,6 @@ class ExchangeConfig {
   bool _validateDepositAddressesInFile;
   bool _placeSimulateRealOrder;
   bool _validateApiKey;
+  bool _withMarketSerialization;
 };
 }  // namespace cct
diff --git a/src/objects/include/marketorderbook.hpp b/src/objects/include/marketorderbook.hpp
index 9a065be2..a77cf6e0 100644
--- a/src/objects/include/marketorderbook.hpp
+++ b/src/objects/include/marketorderbook.hpp
@@ -11,6 +11,7 @@
 #include "monetaryamount.hpp"
 #include "simpletable.hpp"
 #include "timedef.hpp"
+#include "tradeside.hpp"
 #include "volumeandpricenbdecimals.hpp"
 
 namespace cct {
@@ -110,6 +111,8 @@ class MarketOrderBook {
   /// If operation is not possible, return an empty vector.
   AmountPerPriceVec computePricesAtWhichAmountWouldBeSoldImmediately(MonetaryAmount ma) const;
 
+  AmountPerPriceVec computeMatchedParts(TradeSide tradeSide, MonetaryAmount amount, MonetaryAmount price) const;
+
   /// Given an amount in either base or quote currency, attempt to convert it at market price immediately and return
   /// the average price matched.
   std::optional<MonetaryAmount> computeAvgPriceForTakerAmount(MonetaryAmount amountInBaseOrQuote) const;
diff --git a/src/api-objects/include/publictrade.hpp b/src/objects/include/publictrade.hpp
similarity index 100%
rename from src/api-objects/include/publictrade.hpp
rename to src/objects/include/publictrade.hpp
diff --git a/src/api-objects/include/tradeside.hpp b/src/objects/include/tradeside.hpp
similarity index 100%
rename from src/api-objects/include/tradeside.hpp
rename to src/objects/include/tradeside.hpp
diff --git a/src/objects/src/coincentercommandtype.cpp b/src/objects/src/coincentercommandtype.cpp
index e074ddd6..6080d50c 100644
--- a/src/objects/src/coincentercommandtype.cpp
+++ b/src/objects/src/coincentercommandtype.cpp
@@ -31,6 +31,9 @@ constexpr std::string_view kCommandTypeNames[] = {
     "Sell",
     "Withdraw",
     "DustSweeper",
+
+    "Replay",
+    "ReplayMarkets",
 };
 }
 
@@ -63,4 +66,4 @@ bool IsAnyTrade(CoincenterCommandType type) {
       return false;
   }
 }
-}  // namespace cct
\ No newline at end of file
+}  // namespace cct
diff --git a/src/objects/src/exchangeconfig.cpp b/src/objects/src/exchangeconfig.cpp
index 8c325e66..d3f1019b 100644
--- a/src/objects/src/exchangeconfig.cpp
+++ b/src/objects/src/exchangeconfig.cpp
@@ -58,14 +58,17 @@ auto DustSweeperMaxNbTrades(int dustSweeperMaxNbTrades) {
 }
 }  // namespace
 
-ExchangeConfig::ExchangeConfig(
-    std::string_view exchangeNameStr, std::string_view makerStr, std::string_view takerStr,
-    CurrencyCodeVector &&excludedAllCurrencies, CurrencyCodeVector &&excludedCurrenciesWithdraw,
-    CurrencyCodeVector &&preferredPaymentCurrencies, MonetaryAmountByCurrencySet &&dustAmountsThreshold,
-    const APIUpdateFrequencies &apiUpdateFrequencies, Duration publicAPIRate, Duration privateAPIRate,
-    std::string_view acceptEncoding, int dustSweeperMaxNbTrades, log::level::level_enum requestsCallLogLevel,
-    log::level::level_enum requestsAnswerLogLevel, bool multiTradeAllowedByDefault, bool validateDepositAddressesInFile,
-    bool placeSimulateRealOrder, bool validateApiKey, TradeConfig tradeConfig)
+ExchangeConfig::ExchangeConfig(std::string_view exchangeNameStr, std::string_view makerStr, std::string_view takerStr,
+                               CurrencyCodeVector &&excludedAllCurrencies,
+                               CurrencyCodeVector &&excludedCurrenciesWithdraw,
+                               CurrencyCodeVector &&preferredPaymentCurrencies,
+                               MonetaryAmountByCurrencySet &&dustAmountsThreshold,
+                               const APIUpdateFrequencies &apiUpdateFrequencies, Duration publicAPIRate,
+                               Duration privateAPIRate, std::string_view acceptEncoding, int dustSweeperMaxNbTrades,
+                               log::level::level_enum requestsCallLogLevel,
+                               log::level::level_enum requestsAnswerLogLevel, bool multiTradeAllowedByDefault,
+                               bool validateDepositAddressesInFile, bool placeSimulateRealOrder, bool validateApiKey,
+                               TradeConfig tradeConfig, MarketDataSerialization marketDataSerialization)
     : _excludedCurrenciesAll(std::move(excludedAllCurrencies)),
       _excludedCurrenciesWithdrawal(std::move(excludedCurrenciesWithdraw)),
       _preferredPaymentCurrencies(std::move(preferredPaymentCurrencies)),
@@ -83,7 +86,8 @@ ExchangeConfig::ExchangeConfig(
       _multiTradeAllowedByDefault(multiTradeAllowedByDefault),
       _validateDepositAddressesInFile(validateDepositAddressesInFile),
       _placeSimulateRealOrder(placeSimulateRealOrder),
-      _validateApiKey(validateApiKey) {
+      _validateApiKey(validateApiKey),
+      _withMarketSerialization(marketDataSerialization == MarketDataSerialization::kYes) {
   if (dustSweeperMaxNbTrades > std::numeric_limits<int16_t>::max() || dustSweeperMaxNbTrades < 0) {
     throw exception("Invalid number of dust sweeper max trades '{}', should be in [0, {}]", dustSweeperMaxNbTrades,
                     std::numeric_limits<int16_t>::max());
@@ -109,6 +113,7 @@ ExchangeConfig::ExchangeConfig(
                _validateDepositAddressesInFile ? kDepositAddressesFileName : "");
     log::trace(" - Order placing in simulation  : {}", _placeSimulateRealOrder ? "real, unmatchable" : "none");
     log::trace(" - Validate API Key             : {}", _validateApiKey ? "yes" : "no");
+    log::trace(" - Market data serialization    : {}", _withMarketSerialization ? "yes" : "no");
   }
   if (_preferredPaymentCurrencies.empty()) {
     log::warn("{} list of preferred currencies is empty, buy and sell commands cannot perform trades", exchangeNameStr);
diff --git a/src/objects/src/exchangeconfigdefault.hpp b/src/objects/src/exchangeconfigdefault.hpp
index f1b0143f..0bdbf0f4 100644
--- a/src/objects/src/exchangeconfigdefault.hpp
+++ b/src/objects/src/exchangeconfigdefault.hpp
@@ -56,6 +56,7 @@ struct ExchangeConfigDefault {
         "requestsCall": "info",
         "requestsAnswer": "trace"
       },
+      "marketDataSerialization": true,
       "multiTradeAllowedByDefault": false,
       "placeSimulateRealOrder": false,
       "trade": {
@@ -180,6 +181,7 @@ struct ExchangeConfigDefault {
         "requestsCall": "info",
         "requestsAnswer": "trace"
       },
+      "marketDataSerialization": false,
       "multiTradeAllowedByDefault": true,
       "privateAPIRate": "1055ms",
       "publicAPIRate": "1236ms",
diff --git a/src/objects/src/exchangeconfigmap.cpp b/src/objects/src/exchangeconfigmap.cpp
index 905bfc90..f1782075 100644
--- a/src/objects/src/exchangeconfigmap.cpp
+++ b/src/objects/src/exchangeconfigmap.cpp
@@ -57,6 +57,10 @@ ExchangeConfigMap ComputeExchangeConfigMap(std::string_view fileName, const json
         withdrawTopLevelOption.getBool(exchangeName, "validateDepositAddressesInFile");
     const bool placeSimulatedRealOrder = queryTopLevelOption.getBool(exchangeName, "placeSimulateRealOrder");
     const bool validateApiKey = queryTopLevelOption.getBool(exchangeName, "validateApiKey");
+    const ExchangeConfig::MarketDataSerialization marketDataSerialization =
+        queryTopLevelOption.getBool(exchangeName, "marketDataSerialization")
+            ? ExchangeConfig::MarketDataSerialization::kYes
+            : ExchangeConfig::MarketDataSerialization::kNo;
 
     MonetaryAmountByCurrencySet dustAmountsThresholds(
         queryTopLevelOption.getMonetaryAmountsArray(exchangeName, "dustAmountsThreshold"));
@@ -84,7 +88,7 @@ ExchangeConfigMap ComputeExchangeConfigMap(std::string_view fileName, const json
                        std::move(dustAmountsThresholds), std::move(apiUpdateFrequencies), publicAPIRate, privateAPIRate,
                        acceptEncoding, dustSweeperMaxNbTrades, requestsCallLogLevel, requestsAnswerLogLevel,
                        multiTradeAllowedByDefault, validateDepositAddressesInFile, placeSimulatedRealOrder,
-                       validateApiKey, std::move(tradeConfig)));
+                       validateApiKey, std::move(tradeConfig), marketDataSerialization));
   }  // namespace cct
 
   // Print json unused values
@@ -114,4 +118,4 @@ ExchangeConfigMap ComputeExchangeConfigMap(std::string_view fileName, const json
 
   return map;
 }
-}  // namespace cct
\ No newline at end of file
+}  // namespace cct
diff --git a/src/objects/src/marketorderbook.cpp b/src/objects/src/marketorderbook.cpp
index 1b3d64dd..20dab692 100644
--- a/src/objects/src/marketorderbook.cpp
+++ b/src/objects/src/marketorderbook.cpp
@@ -340,6 +340,52 @@ MarketOrderBook::AmountPerPriceVec MarketOrderBook::computePricesAtWhichAmountWo
   return ret;
 }
 
+MarketOrderBook::AmountPerPriceVec MarketOrderBook::computeMatchedParts(TradeSide tradeSide, MonetaryAmount amount,
+                                                                        MonetaryAmount price) const {
+  AmountPerPriceVec ret;
+  const int nbOrders = _orders.size();
+  const auto volumeNbDecimals = _volAndPriNbDecimals.volNbDecimals;
+  const std::optional<AmountType> integralTotalAmountOpt = amount.amount(volumeNbDecimals);
+  if (!integralTotalAmountOpt) {
+    return ret;
+  }
+  AmountType integralTotalAmount = *integralTotalAmountOpt;
+  const auto countAmount = [volumeNbDecimals, &ret, &integralTotalAmount, cur = amount.currencyCode()](
+                               MonetaryAmount price, const AmountType intAmount) {
+    if (intAmount < integralTotalAmount) {
+      ret.emplace_back(MonetaryAmount(intAmount, cur, volumeNbDecimals), price);
+      integralTotalAmount -= intAmount;
+    } else {
+      ret.emplace_back(MonetaryAmount(integralTotalAmount, cur, volumeNbDecimals), price);
+      integralTotalAmount = 0;
+    }
+  };
+  switch (tradeSide) {
+    case TradeSide::kBuy:
+      for (int pos = _highestBidPricePos + 1; pos < nbOrders && integralTotalAmount > 0; ++pos) {
+        // amount is < 0 here
+        const auto linePrice = priceAt(pos);
+        if (price < linePrice) {
+          break;
+        }
+        countAmount(linePrice, -_orders[pos].amount);
+      }
+      break;
+    case TradeSide::kSell:
+      for (int pos = _lowestAskPricePos - 1; pos >= 0 && integralTotalAmount > 0; --pos) {
+        const auto linePrice = priceAt(pos);
+        if (price > linePrice) {
+          break;
+        }
+        countAmount(linePrice, _orders[pos].amount);
+      }
+      break;
+    default:
+      unreachable();
+  }
+  return ret;
+}
+
 std::optional<MonetaryAmount> MarketOrderBook::computeAvgPriceAtWhichAmountWouldBeSoldImmediately(
     MonetaryAmount ma) const {
   return ComputeAvgPrice(_market, computePricesAtWhichAmountWouldBeSoldImmediately(ma));
diff --git a/src/api-objects/src/publictrade.cpp b/src/objects/src/publictrade.cpp
similarity index 100%
rename from src/api-objects/src/publictrade.cpp
rename to src/objects/src/publictrade.cpp
diff --git a/src/objects/test/marketorderbook_test.cpp b/src/objects/test/marketorderbook_test.cpp
index 6f092adf..ab8c34f7 100644
--- a/src/objects/test/marketorderbook_test.cpp
+++ b/src/objects/test/marketorderbook_test.cpp
@@ -10,6 +10,7 @@
 #include "market.hpp"
 #include "monetaryamount.hpp"
 #include "timedef.hpp"
+#include "tradeside.hpp"
 
 namespace cct {
 namespace {
@@ -158,6 +159,29 @@ TEST_F(MarketOrderBookTestCase2, ConvertQuoteAmountToBase) {
   EXPECT_EQ(marketOrderBook.convert(MonetaryAmount("500000", "KRW")), MonetaryAmount("8649.3845211510554", "APM"));
 }
 
+TEST_F(MarketOrderBookTestCase2, ComputeMatchedPartsBuy) {
+  EXPECT_EQ(
+      marketOrderBook.computeMatchedParts(TradeSide::kBuy, MonetaryAmount(91000, "APM"),
+                                          MonetaryAmount("57.81", "KRW")),
+      AmountAtPriceVec({AmountAtPrice(MonetaryAmount("33.5081914157147", "APM"), MonetaryAmount("57.78", "KRW")),
+                        AmountAtPrice(MonetaryAmount("1991.3922", "APM"), MonetaryAmount("57.8", "KRW")),
+                        AmountAtPrice(MonetaryAmount("88975.0996085842853", "APM"), MonetaryAmount("57.81", "KRW"))}));
+  EXPECT_EQ(marketOrderBook.computeMatchedParts(TradeSide::kBuy, MonetaryAmount(91000, "APM"),
+                                                MonetaryAmount("57.77", "KRW")),
+            AmountAtPriceVec());
+}
+
+TEST_F(MarketOrderBookTestCase2, ComputeMatchedPartsSell) {
+  EXPECT_EQ(marketOrderBook.computeMatchedParts(TradeSide::kSell, MonetaryAmount(5000, "APM"),
+                                                MonetaryAmount("57.19", "KRW")),
+            AmountAtPriceVec({
+                AmountAtPrice(MonetaryAmount("3890.879", "APM"), MonetaryAmount("57.19", "KRW")),
+            }));
+  EXPECT_EQ(marketOrderBook.computeMatchedParts(TradeSide::kSell, MonetaryAmount(91000, "APM"),
+                                                MonetaryAmount("57.23", "KRW")),
+            AmountAtPriceVec());
+}
+
 class MarketOrderBookTestCase3 : public ::testing::Test {
  protected:
   TimePoint time{};
diff --git a/src/serialization/CMakeLists.txt b/src/serialization/CMakeLists.txt
new file mode 100644
index 00000000..9927a9b8
--- /dev/null
+++ b/src/serialization/CMakeLists.txt
@@ -0,0 +1,34 @@
+if(CCT_ENABLE_PROTO)
+  aux_source_directory(src SERIALIZATION_SRC)
+
+  list(APPEND SERIALIZATION_SRC "${CMAKE_CURRENT_LIST_DIR}/proto/market-order-book-timed-data.proto")
+  list(APPEND SERIALIZATION_SRC "${CMAKE_CURRENT_LIST_DIR}/proto/trade-data.proto")
+else()
+  set(SERIALIZATION_SRC "src/dummy-market-data-serializer.cpp" "src/dummy-market-data-deserializer.cpp")
+endif()
+
+add_library(coincenter_serialization OBJECT ${SERIALIZATION_SRC})
+
+target_include_directories(coincenter_serialization PUBLIC include)
+target_link_libraries(coincenter_serialization PUBLIC coincenter_objects)
+
+if(CCT_ENABLE_PROTO)
+  set(PROTO_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated")
+
+  target_include_directories(coincenter_serialization PUBLIC "$<BUILD_INTERFACE:${PROTO_BINARY_DIR}>")
+
+  target_link_libraries(coincenter_serialization PUBLIC protobuf::libprotobuf)
+
+  protobuf_generate(
+    TARGET coincenter_serialization
+    IMPORT_DIRS "${CMAKE_CURRENT_LIST_DIR}/proto"
+    PROTOC_OUT_DIR "${PROTO_BINARY_DIR}"
+  )
+
+  add_unit_test(
+    proto-multiple-messages-handler_test
+    test/proto-multiple-messages-handler_test.cpp
+    LIBRARIES
+    coincenter_serialization
+  )
+endif()
\ No newline at end of file
diff --git a/src/serialization/include/abstract-market-data-deserializer.hpp b/src/serialization/include/abstract-market-data-deserializer.hpp
new file mode 100644
index 00000000..c39c9452
--- /dev/null
+++ b/src/serialization/include/abstract-market-data-deserializer.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "cct_vector.hpp"
+#include "market.hpp"
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+#include "time-window.hpp"
+
+namespace cct {
+class AbstractMarketDataDeserializer {
+ public:
+  virtual ~AbstractMarketDataDeserializer() = default;
+
+  virtual vector<Market> pullMarketOrderBooksMarkets(TimeWindow timeWindow) = 0;
+
+  virtual vector<Market> pullTradeMarkets(TimeWindow timeWindow) = 0;
+
+  virtual vector<MarketOrderBook> pullMarketOrderBooks(Market market, TimeWindow timeWindow) = 0;
+
+  virtual vector<PublicTrade> pullTrades(Market market, TimeWindow timeWindow) = 0;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/abstract-market-data-serializer.hpp b/src/serialization/include/abstract-market-data-serializer.hpp
new file mode 100644
index 00000000..a38e8342
--- /dev/null
+++ b/src/serialization/include/abstract-market-data-serializer.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <span>
+
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+
+namespace cct {
+class AbstractMarketDataSerializer {
+ public:
+  virtual ~AbstractMarketDataSerializer() = default;
+
+  virtual void push(const MarketOrderBook &marketOrderBook) = 0;
+
+  virtual void push(std::span<const PublicTrade> publicTrades) = 0;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/dummy-market-data-deserializer.hpp b/src/serialization/include/dummy-market-data-deserializer.hpp
new file mode 100644
index 00000000..8a714842
--- /dev/null
+++ b/src/serialization/include/dummy-market-data-deserializer.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string_view>
+
+#include "abstract-market-data-deserializer.hpp"
+#include "cct_vector.hpp"
+#include "market.hpp"
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+#include "time-window.hpp"
+
+namespace cct {
+class DummyMarketDataDeserializer : public AbstractMarketDataDeserializer {
+ public:
+  DummyMarketDataDeserializer([[maybe_unused]] std::string_view dataDir,
+                              [[maybe_unused]] std::string_view exchangeName);
+
+  vector<Market> pullMarketOrderBooksMarkets([[maybe_unused]] TimeWindow timeWindow) override;
+
+  vector<Market> pullTradeMarkets([[maybe_unused]] TimeWindow timeWindow) override;
+
+  vector<MarketOrderBook> pullMarketOrderBooks([[maybe_unused]] Market market,
+                                               [[maybe_unused]] TimeWindow timeWindow) override;
+
+  vector<PublicTrade> pullTrades([[maybe_unused]] Market market, [[maybe_unused]] TimeWindow timeWindow) override;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/dummy-market-data-serializer.hpp b/src/serialization/include/dummy-market-data-serializer.hpp
new file mode 100644
index 00000000..1771c0f8
--- /dev/null
+++ b/src/serialization/include/dummy-market-data-serializer.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <span>
+#include <string_view>
+
+#include "abstract-market-data-serializer.hpp"
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+
+namespace cct {
+/// Implementation of a market data serializer that does nothing.
+/// Useful if coincenter is not compiled with protobuf support.
+class DummyMarketDataSerializer : public AbstractMarketDataSerializer {
+ public:
+  DummyMarketDataSerializer([[maybe_unused]] std::string_view dataDir, [[maybe_unused]] std::string_view exchangeName);
+
+  void push([[maybe_unused]] const MarketOrderBook &marketOrderBook) override;
+
+  void push([[maybe_unused]] std::span<const PublicTrade> publicTrades) override;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-constants.hpp b/src/serialization/include/proto-constants.hpp
new file mode 100644
index 00000000..f820e648
--- /dev/null
+++ b/src/serialization/include/proto-constants.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstdint>
+#include <string_view>
+
+namespace cct {
+
+enum class ProtobufObject : int8_t { kMarketOrderBook, kTrade };
+
+static constexpr std::string_view kBinProtobufExtension = ".binpb";
+
+static constexpr std::string_view kSubPathMarketOrderBook = "market-order-book";
+static constexpr std::string_view kSubPathTrades = "trades";
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-deserializer.hpp b/src/serialization/include/proto-deserializer.hpp
new file mode 100644
index 00000000..b06d3394
--- /dev/null
+++ b/src/serialization/include/proto-deserializer.hpp
@@ -0,0 +1,160 @@
+#pragma once
+
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include "cct_log.hpp"
+#include "cct_vector.hpp"
+#include "market.hpp"
+#include "proto-multiple-messages-handler.hpp"
+#include "time-window.hpp"
+#include "timedef.hpp"
+
+namespace cct {
+
+template <class ProtobufObjType, class ProtoToCoincenterObjectsFunc>
+class ProtobufObjectsDeserializer {
+ public:
+  using CoincenterObjectType = std::invoke_result_t<ProtoToCoincenterObjectsFunc, const ProtobufObjType&>;
+
+  explicit ProtobufObjectsDeserializer(std::string_view exchangeSerializedDataPath)
+      : _exchangeSerializedDataPath(exchangeSerializedDataPath) {}
+
+  /// Load all markets found on disk which has some data in the given time window
+  vector<Market> listMarkets(TimeWindow timeWindow) {
+    vector<Market> ret;
+
+    const auto pathStr = _exchangeSerializedDataPath;
+    if (!std::filesystem::is_directory(pathStr)) {
+      return ret;
+    }
+
+    for (const auto& marketDirectory : std::filesystem::directory_iterator(pathStr)) {
+      if (loadMarket(marketDirectory, timeWindow, ActionType::kCheckPresence).second) {
+        const auto& marketPath = marketDirectory.path();
+        const auto marketStr = marketPath.filename().string();
+
+        ret.emplace_back(marketStr);
+      }
+    }
+
+    return ret;
+  }
+
+  /// Load all data found on disk for given market for the time window
+  vector<CoincenterObjectType> loadMarket(Market market, TimeWindow timeWindow) {
+    std::string marketPathStr(_exchangeSerializedDataPath);
+    marketPathStr.push_back('/');
+    marketPathStr.append(market.str());
+
+    std::filesystem::path marketPath(marketPathStr);
+
+    return loadMarket(std::filesystem::directory_entry(marketPath), timeWindow);
+  }
+
+  /// Load all data found on disk for given market for the time window
+  vector<CoincenterObjectType> loadMarket(const std::filesystem::directory_entry& marketDirectory,
+                                          TimeWindow timeWindow) {
+    return loadMarket(marketDirectory, timeWindow, ActionType::kLoad).first;
+  }
+
+ private:
+  static bool ValidateTimestamp(const ProtobufObjType& msg, TimeWindow timeWindow) {
+    if (!msg.has_unixtimestampinms()) {
+      log::error("Invalid data loaded for protobuf object, no unix timestamp set");
+      return false;
+    }
+    return timeWindow.contains(msg.unixtimestampinms());
+  }
+
+  enum class ActionType : int8_t { kLoad, kCheckPresence };
+
+  /// Load all data found on disk for given market for the time window
+  std::pair<vector<CoincenterObjectType>, bool> loadMarket(const std::filesystem::directory_entry& marketDirectory,
+                                                           TimeWindow timeWindow, ActionType actionType) {
+    std::pair<vector<CoincenterObjectType>, bool> ret(vector<CoincenterObjectType>(), false);
+    if (!marketDirectory.is_directory()) {
+      return ret;
+    }
+    const auto fromDays = std::chrono::floor<std::chrono::days>(timeWindow.from());
+    const std::chrono::year_month_day fromYmd{fromDays};
+    const std::chrono::hh_mm_ss fromTime{std::chrono::floor<TimeInMs>(timeWindow.from() - fromDays)};
+
+    const auto toDays = std::chrono::floor<std::chrono::days>(timeWindow.to());
+    const std::chrono::year_month_day toYmd{toDays};
+    const std::chrono::hh_mm_ss toTime{std::chrono::floor<TimeInMs>(timeWindow.to() - toDays)};
+
+    const auto& marketPath = marketDirectory.path();
+    const auto marketStr = marketPath.filename().string();
+    const Market market(marketStr);
+
+    ProtoToCoincenterObjectsFunc converter(market);
+
+    const int fromYear = static_cast<int>(fromYmd.year());
+    const int toYear = static_cast<int>(toYmd.year());
+    for (int year = fromYear; year <= toYear; ++year) {
+      const auto yearPath = marketPath / fmt::format("{:04}", year);
+      if (!std::filesystem::is_directory(yearPath)) {
+        continue;
+      }
+      const auto fromMonth = year == fromYear ? static_cast<unsigned int>(fromYmd.month()) : 1U;
+      const auto toMonth = year == toYear ? static_cast<unsigned int>(toYmd.month()) : 12U;
+      for (std::remove_const_t<decltype(fromMonth)> month = fromMonth; month <= toMonth; ++month) {
+        const auto monthPath = yearPath / fmt::format("{:02}", month);
+        if (!std::filesystem::is_directory(monthPath)) {
+          continue;
+        }
+        const auto fromDay = year == fromYear && month == fromMonth ? static_cast<unsigned int>(fromYmd.day()) : 1U;
+        const auto toDay = year == toYear && month == toMonth ? static_cast<unsigned int>(toYmd.day()) : 31U;
+        for (std::remove_const_t<decltype(fromDay)> day = fromDay; day <= toDay; ++day) {
+          const auto dayPath = monthPath / fmt::format("{:02}", day);
+          if (!std::filesystem::is_directory(dayPath)) {
+            continue;
+          }
+          for (const auto& binProtobufFile : std::filesystem::directory_iterator(dayPath)) {
+            if (!binProtobufFile.is_regular_file()) {
+              continue;
+            }
+            const auto& filePath = binProtobufFile.path();
+            const auto fileName = filePath.filename().string();
+
+            int hour{};
+            const auto [ptr, ec] = std::from_chars(fileName.data(), fileName.data() + 2, hour);
+            if (ec != std::errc() || ptr - fileName.data() != 2) {
+              log::error("Unable to load bin protobuf file {} because of error {} trying to convert to hour range",
+                         filePath.string(), static_cast<int>(ec));
+              continue;
+            }
+            if (year == toYear && month == toMonth && day == toDay &&
+                hour > std::chrono::duration_cast<std::chrono::hours>(toTime.hours()).count()) {
+              // not within our time window
+              continue;
+            }
+            std::ifstream ifs(filePath, std::ios::in | std::ios::binary);
+            ProtobufMessagesReader multipleProtobufMessagesReader(ifs);
+            while (multipleProtobufMessagesReader.hasNext()) {
+              auto msg = multipleProtobufMessagesReader.next<ProtobufObjType>();
+              if (!ValidateTimestamp(msg, timeWindow)) {
+                continue;
+              }
+              ret.second = true;
+              if (actionType == ActionType::kCheckPresence) {
+                return ret;
+              }
+              ret.first.push_back(converter(std::move(msg)));
+            }
+          }
+        }
+      }
+    }
+    return ret;
+  }
+
+  std::string_view _exchangeSerializedDataPath;
+};
+
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-market-accumulator.hpp b/src/serialization/include/proto-market-accumulator.hpp
new file mode 100644
index 00000000..c9f4655d
--- /dev/null
+++ b/src/serialization/include/proto-market-accumulator.hpp
@@ -0,0 +1,198 @@
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <cstddef>
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+
+#include "cct_log.hpp"
+#include "cct_vector.hpp"
+#include "durationstring.hpp"
+#include "market.hpp"
+#include "proto-constants.hpp"
+#include "proto-multiple-messages-handler.hpp"
+#include "stringhelpers.hpp"
+#include "timedef.hpp"
+
+namespace cct {
+/// Class responsible to accumulate protobuf objects in memory and perform regular flushes of its data to the disk.
+/// Data is accumulated by Market and will write to following files (from subPath):
+///  'BASECUR-QUOTECUR/YYYY/MM/DD/HH:00:00_HH:59:59.binpb'
+///
+/// If you may push duplicated objects, you have to provide Comp and Equal types.
+/// In this case, Equal must be consistent with Comp, and the first criteria of the comparison should be the timestamp
+/// (ordered from oldest to youngest).
+///
+/// You may not provide any Comp and Equal if by design you will not push duplicated data.
+template <class ProtobufObjectType, class Comp = void, class Equal = void>
+class MarketDataAccumulator {
+ public:
+  static_assert((std::is_void_v<Comp> && std::is_void_v<Equal>) || (!std::is_void_v<Comp> && !std::is_void_v<Equal>));
+
+  using ProtobufObjectTypeVector = vector<ProtobufObjectType>;
+  using ProtobufObjectTypePerMarketMap = std::unordered_map<Market, ProtobufObjectTypeVector>;
+
+  explicit MarketDataAccumulator(std::string subPath, std::size_t nbObjectsPerMarketInMemory) noexcept
+      : _subPath(std::move(subPath)), _nbObjectsPerMarketInMemory(nbObjectsPerMarketInMemory) {}
+
+  MarketDataAccumulator(const MarketDataAccumulator &) = delete;
+  MarketDataAccumulator &operator=(const MarketDataAccumulator &) = delete;
+
+  MarketDataAccumulator(MarketDataAccumulator &&other) noexcept { swap(other); }
+
+  MarketDataAccumulator &operator=(MarketDataAccumulator &&other) noexcept {
+    finalWriteOnDiskNoExcept();
+    swap(other);
+    return *this;
+  }
+
+  ~MarketDataAccumulator() { finalWriteOnDiskNoExcept(); }
+
+  void push(Market market, const ProtobufObjectType &protoObj) {
+    auto &protobufObjectsVector = _toBeFlushedData[market];
+    protobufObjectsVector.push_back(protoObj);
+    registerPush(market, protobufObjectsVector);
+  }
+
+  void push(Market market, ProtobufObjectType &&protoObj) {
+    auto &protobufObjectsVector = _toBeFlushedData[market];
+    protobufObjectsVector.push_back(std::move(protoObj));
+    registerPush(market, protobufObjectsVector);
+  }
+
+  void setDirectory(Market market, TimePoint tp, std::string &pathStr) const {
+    // Note: below code  could be simplified once compilers fully implement std::format and chrono C++20
+    // libraries.
+    const auto dp = std::chrono::floor<std::chrono::days>(tp);
+    const std::chrono::year_month_day ymd{dp};
+
+    pathStr.replace(pathStr.begin() + _subPath.size(), pathStr.end(),
+                    fmt::format("{}/{:04}/{:02}/{:02}/", market.str(), static_cast<int>(ymd.year()),
+                                static_cast<unsigned int>(ymd.month()), static_cast<unsigned int>(ymd.day())));
+  }
+
+  static void AddFilePath(TimePoint tp, std::string &pathStr) {
+    const auto dp = std::chrono::floor<std::chrono::days>(tp);
+    const std::chrono::hh_mm_ss time{std::chrono::floor<std::chrono::milliseconds>(tp - dp)};
+
+    const auto dayHour = std::chrono::duration_cast<std::chrono::hours>(time.hours()).count();
+    const auto beforeHoursSize = pathStr.size();
+    if (dayHour < 10) {
+      pathStr.push_back('0');
+    }
+    AppendString(pathStr, dayHour);
+    const auto afterHoursSize = pathStr.size();
+    pathStr.append(":00:00_");
+    pathStr.append(pathStr.begin() + beforeHoursSize, pathStr.begin() + afterHoursSize);
+    pathStr.append(":59:59");
+    pathStr.append(kBinProtobufExtension);
+  }
+
+  void swap(MarketDataAccumulator &rhs) noexcept {
+    _toBeFlushedData.swap(rhs._toBeFlushedData);
+    _subPath.swap(rhs._subPath);
+    std::swap(_nbObjectsPerMarketInMemory, rhs._nbObjectsPerMarketInMemory);
+  }
+
+ private:
+  void finalWriteOnDiskNoExcept() noexcept {
+    try {
+      for (auto &[market, protobufObjectsVector] : _toBeFlushedData) {
+        writeOnDisk(market, protobufObjectsVector);
+      }
+    } catch (const std::exception &e) {
+      log::error("exception caught in writeOnDisk: {}", e.what());
+    }
+  }
+
+  void registerPush(Market market, ProtobufObjectTypeVector &protobufObjectsVector) {
+    if (protobufObjectsVector.size() == _nbObjectsPerMarketInMemory) {
+      writeOnDisk(market, protobufObjectsVector);
+    }
+  }
+
+  void writeOnDisk(Market market, ProtobufObjectTypeVector &protobufObjectsVector) {
+    const auto nowTime = std::chrono::steady_clock::now();
+
+    Filter(market, protobufObjectsVector);
+
+    std::string pathStr = _subPath;
+
+    std::chrono::time_point<Clock, std::chrono::hours> prevHours{};
+    ProtobufMessagesWriter<std::ofstream> protobufMessagesWriter;
+    for (const auto &protobufObject : protobufObjectsVector) {
+      openFile(market, protobufObject, prevHours, pathStr, protobufMessagesWriter);
+
+      protobufMessagesWriter.write(protobufObject);
+    }
+
+    //  shrink_to_fit as vector will never grow-up larger than its current size
+    protobufObjectsVector.shrink_to_fit();
+
+    const auto nbElemsWritten = protobufObjectsVector.size();
+    protobufObjectsVector.clear();
+
+    if (nbElemsWritten != 0) {
+      const auto steadyClockDuration = std::chrono::steady_clock::now() - nowTime;
+      const Duration dur = std::chrono::duration_cast<Duration>(steadyClockDuration);
+
+      log::info("Wrote {} objects for {} timed data in {}, last in {}", nbElemsWritten, market, DurationToString(dur),
+                pathStr);
+    }
+  }
+
+  static void Filter(Market market, ProtobufObjectTypeVector &protobufObjectsVector) {
+    // Sort by timestamp (required by 'writeOnDisk' algorithm) and removes invalid elements (if any)
+    std::ranges::sort(protobufObjectsVector, [](const auto &lhs, const auto &rhs) {
+      if (lhs.has_unixtimestampinms() != rhs.has_unixtimestampinms()) {
+        return lhs.has_unixtimestampinms();
+      }
+      if (!lhs.has_unixtimestampinms()) {
+        return false;
+      }
+      return lhs.unixtimestampinms() < rhs.unixtimestampinms();
+    });
+    auto begInvalidElemsIt = std::ranges::partition_point(
+        protobufObjectsVector, [](const auto &protoObj) { return protoObj.has_unixtimestampinms(); });
+    if (begInvalidElemsIt != protobufObjectsVector.end()) {
+      log::error("Invalid data for {} - no timestamp set for {} objects", market,
+                 protobufObjectsVector.end() - begInvalidElemsIt);
+      protobufObjectsVector.erase(begInvalidElemsIt, protobufObjectsVector.end());
+    }
+
+    // If duplicate elements are possible, remove them
+    if constexpr (!std::is_void_v<Comp>) {
+      std::ranges::sort(protobufObjectsVector, Comp{});
+      const auto [ret, last] = std::ranges::unique(protobufObjectsVector, Equal{});
+      protobufObjectsVector.erase(ret, protobufObjectsVector.end());
+    }
+  }
+
+  void openFile(Market market, const ProtobufObjectType &protobufObject,
+                std::chrono::time_point<Clock, std::chrono::hours> &prevHours, std::string &pathStr,
+                ProtobufMessagesWriter<std::ofstream> &protobufMessagesWriter) {
+    const TimePoint tp{std::chrono::milliseconds{protobufObject.unixtimestampinms()}};
+    const auto hours = std::chrono::floor<std::chrono::hours>(tp);
+
+    if (prevHours != hours) {
+      // reset outfile
+      setDirectory(market, tp, pathStr);
+      std::filesystem::create_directories(std::filesystem::path(pathStr));
+      AddFilePath(tp, pathStr);
+      std::filesystem::path filePath(pathStr);
+
+      protobufMessagesWriter.open(std::ofstream(filePath, std::ios_base::app));
+      prevHours = hours;
+    }
+  }
+
+  ProtobufObjectTypePerMarketMap _toBeFlushedData;
+  std::string _subPath;
+  std::size_t _nbObjectsPerMarketInMemory;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-market-data-deserializer.hpp b/src/serialization/include/proto-market-data-deserializer.hpp
new file mode 100644
index 00000000..27f455e4
--- /dev/null
+++ b/src/serialization/include/proto-market-data-deserializer.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <string_view>
+
+#include "abstract-market-data-deserializer.hpp"
+#include "cct_vector.hpp"
+#include "market-order-book-timed-data.pb.h"
+#include "market.hpp"
+#include "marketorderbook.hpp"
+#include "proto-deserializer.hpp"
+#include "proto-market-order-book.hpp"
+#include "proto-public-trade.hpp"
+#include "publictrade.hpp"
+#include "time-window.hpp"
+#include "trade-data.pb.h"
+
+namespace cct {
+
+class ProtoMarketDataDeserializer : public AbstractMarketDataDeserializer {
+ public:
+  ProtoMarketDataDeserializer(std::string_view dataDir, std::string_view exchangeName);
+
+  vector<Market> pullMarketOrderBooksMarkets(TimeWindow timeWindow) override;
+
+  vector<Market> pullTradeMarkets(TimeWindow timeWindow) override;
+
+  vector<MarketOrderBook> pullMarketOrderBooks(Market market, TimeWindow timeWindow) override;
+
+  vector<PublicTrade> pullTrades(Market market, TimeWindow timeWindow) override;
+
+ private:
+  ProtobufObjectsDeserializer<::objects::MarketOrderBookTimedData, MarketOrderBookConverter>
+      _marketOrderBookDataGateway;
+  ProtobufObjectsDeserializer<::objects::TradeData, PublicTradeConverter> _tradeDataGateway;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-market-data-serializer.hpp b/src/serialization/include/proto-market-data-serializer.hpp
new file mode 100644
index 00000000..bc096e52
--- /dev/null
+++ b/src/serialization/include/proto-market-data-serializer.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <span>
+#include <string_view>
+
+#include "abstract-market-data-serializer.hpp"
+#include "market-order-book-timed-data.pb.h"
+#include "marketorderbook.hpp"
+#include "proto-market-accumulator.hpp"
+#include "publictrade.hpp"
+#include "timedef.hpp"
+#include "trade-data.pb.h"
+
+namespace cct {
+/// This class is responsible of managing the periodic writes to disk of timed market data, for a given exchange.
+/// This class is not thread safe
+class ProtoMarketDataSerializer : public AbstractMarketDataSerializer {
+ public:
+  ProtoMarketDataSerializer(std::string_view dataDir, std::string_view exchangeName);
+
+  /// Push market order book timed data in the MarketDataSerializer.
+  void push(const MarketOrderBook &marketOrderBook) override;
+
+  /// Push public trades timed data in the MarketDataSerializer.
+  void push(std::span<const PublicTrade> publicTrades) override;
+
+ private:
+  struct TradeDataComp {
+    bool operator()(const ::objects::TradeData &lhs, const ::objects::TradeData &rhs) const;
+  };
+
+  struct TradeDataEqual {
+    bool operator()(const ::objects::TradeData &lhs, const ::objects::TradeData &rhs) const;
+  };
+
+  MarketDataAccumulator<::objects::MarketOrderBookTimedData> _marketOrderBookAccumulator;
+  MarketDataAccumulator<::objects::TradeData, TradeDataComp, TradeDataEqual> _tradesAccumulator;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-market-order-book.hpp b/src/serialization/include/proto-market-order-book.hpp
new file mode 100644
index 00000000..78980d11
--- /dev/null
+++ b/src/serialization/include/proto-market-order-book.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "market-order-book-timed-data.pb.h"
+#include "marketorderbook.hpp"
+
+namespace cct {
+::objects::MarketOrderBookTimedData CreateMarketOrderBookTimedData(const MarketOrderBook &marketOrderBook);
+
+class MarketOrderBookConverter {
+ public:
+  explicit MarketOrderBookConverter(Market market) : _market(market) {}
+
+  MarketOrderBook operator()(const ::objects::MarketOrderBookTimedData &marketOrderBookTimedData);
+
+ private:
+  Market _market;
+  vector<OrderBookLine> _orderBookLines;
+};
+
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-multiple-messages-handler.hpp b/src/serialization/include/proto-multiple-messages-handler.hpp
new file mode 100644
index 00000000..8a14566f
--- /dev/null
+++ b/src/serialization/include/proto-multiple-messages-handler.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <google/protobuf/util/delimited_message_util.h>
+
+#include <cstdint>
+#include <istream>
+
+#include "cct_exception.hpp"
+#include "cct_log.hpp"
+
+namespace cct {
+class ProtobufMessagesReader {
+ public:
+  explicit ProtobufMessagesReader(std::istream& is) : _is(is), _iis(&_is), _cis(&_iis) {}
+
+  bool hasNext() { return _cis.ReadVarint64(&_nextSize); }
+
+  template <class MsgT>
+  MsgT next() {
+    MsgT msg;
+    auto msgLimit = _cis.PushLimit(_nextSize);
+    if (!msg.ParseFromCodedStream(&_cis)) {
+      log::error("Error reading single protobuf message of size {}", _nextSize);
+    }
+    _cis.PopLimit(msgLimit);
+    return msg;
+  }
+
+ private:
+  std::istream& _is;
+  ::google::protobuf::io::IstreamInputStream _iis;
+  ::google::protobuf::io::CodedInputStream _cis;
+  uint64_t _nextSize{};
+};
+
+template <class OStreamType>
+class ProtobufMessagesWriter {
+ public:
+  void open(OStreamType&& newOs) {
+    // reverse destroy streams to flush latest data. Recreate the streams after creation of new ofstream
+    _cos.reset();
+    _oos.reset();
+    _os = std::move(newOs);
+    _oos = std::make_unique<::google::protobuf::io::OstreamOutputStream>(&_os);
+    _cos = std::make_unique<::google::protobuf::io::CodedOutputStream>(_oos.get());
+  }
+
+  template <class MsgT>
+  void write(const MsgT& msg) {
+    if (!_cos) {
+      throw exception("ProtobufMessagesWriter::open should have been called first");
+    }
+
+    _cos->WriteVarint64(msg.ByteSizeLong());
+
+    if (!msg.SerializeToCodedStream(_cos.get())) {
+      log::error("Failed to serialize to coded stream");
+    }
+  }
+
+  OStreamType flush() {
+    _cos.reset();
+    _oos.reset();
+
+    OStreamType ret(std::move(_os));
+    _os = OStreamType();
+    return ret;
+  }
+
+ private:
+  OStreamType _os;
+  std::unique_ptr<::google::protobuf::io::OstreamOutputStream> _oos;
+  std::unique_ptr<::google::protobuf::io::CodedOutputStream> _cos;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/proto-public-trade.hpp b/src/serialization/include/proto-public-trade.hpp
new file mode 100644
index 00000000..a00d7af2
--- /dev/null
+++ b/src/serialization/include/proto-public-trade.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "market.hpp"
+#include "publictrade.hpp"
+#include "trade-data.pb.h"
+
+namespace cct {
+::objects::TradeData CreateTradeData(const PublicTrade &publicTrade);
+
+class PublicTradeConverter {
+ public:
+  explicit PublicTradeConverter(Market market) : _market(market) {}
+
+  PublicTrade operator()(const ::objects::TradeData &tradeData) const;
+
+ private:
+  Market _market;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/serialization-tools.hpp b/src/serialization/include/serialization-tools.hpp
new file mode 100644
index 00000000..35e131eb
--- /dev/null
+++ b/src/serialization/include/serialization-tools.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+
+namespace cct {
+std::string ComputeSubPath(std::string_view dataDir, std::string_view exchangeName,
+                           std::string_view protobufObjectName);
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/include/time-window.hpp b/src/serialization/include/time-window.hpp
new file mode 100644
index 00000000..fd8e9ca6
--- /dev/null
+++ b/src/serialization/include/time-window.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <chrono>
+
+#include "cct_exception.hpp"
+#include "cct_format.hpp"
+#include "timedef.hpp"
+#include "timestring.hpp"
+
+namespace cct {
+
+/// Simple utility class representing a time window with a beginning time, and an end time.
+/// The beginning time includes the corresponding time point, but the end time excludes it.
+class TimeWindow {
+ public:
+  TimeWindow() noexcept = default;
+
+  TimeWindow(TimePoint from, TimePoint to) : _from(from), _to(to) {
+    if (_to < _from) {
+      throw exception("Invalid time window");
+    }
+  }
+
+  TimePoint from() const { return _from; }
+
+  TimePoint to() const { return _to; }
+
+  Duration duration() const { return _from - _to; }
+
+  bool contains(TimePoint tp) const { return tp >= _from && tp < _to; }
+
+  bool contains(int64_t unixTimestampInMs) const { return contains(TimePoint(TimeInMs{unixTimestampInMs})); }
+
+  bool overlap(TimeWindow rhs) const { return _from <= rhs._to && rhs._from <= _to; }
+
+  bool isWithin(TimeWindow rhs) const { return rhs._from <= _from && _to <= rhs._to; }
+
+ private:
+  TimePoint _from{};
+  TimePoint _to{};
+};
+}  // namespace cct
+
+#ifndef CCT_DISABLE_SPDLOG
+template <>
+struct fmt::formatter<cct::TimeWindow> {
+  constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    const auto it = ctx.begin();
+    const auto end = ctx.end();
+    if (it != end && *it != '}') {
+      throw format_error("invalid format");
+    }
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const cct::TimeWindow& timeWindow, FormatContext& ctx) const -> decltype(ctx.out()) {
+    return fmt::format_to(ctx.out(), "[{} -> {})",
+                          cct::ToString(timeWindow.from(), cct::kTimeYearToSecondSpaceSeparatedFormat),
+                          cct::ToString(timeWindow.to(), cct::kTimeYearToSecondSpaceSeparatedFormat));
+  }
+};
+#endif
\ No newline at end of file
diff --git a/src/serialization/proto/market-order-book-timed-data.proto b/src/serialization/proto/market-order-book-timed-data.proto
new file mode 100644
index 00000000..286fdf0b
--- /dev/null
+++ b/src/serialization/proto/market-order-book-timed-data.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package objects;
+
+message MarketOrderBookTimedData {
+  optional int64 unixTimestampInMs = 1;
+  optional int32 volumeNbDecimals = 2;
+  optional int32 priceNbDecimals = 3;
+
+  message PricedVolume {
+    optional int64 price = 1;
+    optional int64 volume = 2;
+  }
+
+  message OrderBook {
+    repeated PricedVolume asks = 1;
+    repeated PricedVolume bids = 2;
+  }
+
+  optional OrderBook orderBook = 4;
+}
\ No newline at end of file
diff --git a/src/serialization/proto/trade-data.proto b/src/serialization/proto/trade-data.proto
new file mode 100644
index 00000000..f1399429
--- /dev/null
+++ b/src/serialization/proto/trade-data.proto
@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+package objects;
+
+enum TradeSide {
+  TRADE_UNSPECIFIED = 0;
+  TRADE_BUY = 1;
+  TRADE_SELL = 2;
+}
+
+message TradeData {
+  optional int64 unixTimestampInMs = 1;
+  optional int64 priceAmount = 2;
+  optional int64 volumeAmount = 3;
+  optional int32 priceNbDecimals = 4;
+  optional int32 volumeNbDecimals = 5;
+  TradeSide tradeSide = 6;
+}
\ No newline at end of file
diff --git a/src/serialization/src/dummy-market-data-deserializer.cpp b/src/serialization/src/dummy-market-data-deserializer.cpp
new file mode 100644
index 00000000..30e5a67d
--- /dev/null
+++ b/src/serialization/src/dummy-market-data-deserializer.cpp
@@ -0,0 +1,25 @@
+#include "dummy-market-data-deserializer.hpp"
+
+namespace cct {
+
+DummyMarketDataDeserializer::DummyMarketDataDeserializer([[maybe_unused]] std::string_view dataDir,
+                                                         [[maybe_unused]] std::string_view exchangeName) {}
+
+vector<Market> DummyMarketDataDeserializer::pullMarketOrderBooksMarkets([[maybe_unused]] TimeWindow timeWindow) {
+  return vector<Market>();
+}
+
+vector<Market> DummyMarketDataDeserializer::pullTradeMarkets([[maybe_unused]] TimeWindow timeWindow) {
+  return vector<Market>();
+}
+
+vector<MarketOrderBook> DummyMarketDataDeserializer::pullMarketOrderBooks([[maybe_unused]] Market market,
+                                                                          [[maybe_unused]] TimeWindow timeWindow) {
+  return vector<MarketOrderBook>();
+}
+
+vector<PublicTrade> DummyMarketDataDeserializer::pullTrades([[maybe_unused]] Market market,
+                                                            [[maybe_unused]] TimeWindow timeWindow) {
+  return vector<PublicTrade>();
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/src/dummy-market-data-serializer.cpp b/src/serialization/src/dummy-market-data-serializer.cpp
new file mode 100644
index 00000000..f24642d9
--- /dev/null
+++ b/src/serialization/src/dummy-market-data-serializer.cpp
@@ -0,0 +1,18 @@
+#include "dummy-market-data-serializer.hpp"
+
+#include <span>
+#include <string_view>
+
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+
+namespace cct {
+
+DummyMarketDataSerializer::DummyMarketDataSerializer([[maybe_unused]] std::string_view dataDir,
+                                                     [[maybe_unused]] std::string_view exchangeName) {}
+
+void DummyMarketDataSerializer::push([[maybe_unused]] const MarketOrderBook &marketOrderBook) {}
+
+void DummyMarketDataSerializer::push([[maybe_unused]] std::span<const PublicTrade> publicTrades) {}
+
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/src/proto-market-data-deserializer.cpp b/src/serialization/src/proto-market-data-deserializer.cpp
new file mode 100644
index 00000000..6fe6911c
--- /dev/null
+++ b/src/serialization/src/proto-market-data-deserializer.cpp
@@ -0,0 +1,28 @@
+#include "proto-market-data-deserializer.hpp"
+
+#include <string_view>
+
+#include "proto-constants.hpp"
+#include "serialization-tools.hpp"
+
+namespace cct {
+ProtoMarketDataDeserializer::ProtoMarketDataDeserializer(std::string_view dataDir, std::string_view exchangeName)
+    : _marketOrderBookDataGateway(ComputeSubPath(dataDir, exchangeName, kSubPathMarketOrderBook)),
+      _tradeDataGateway(ComputeSubPath(dataDir, exchangeName, kSubPathTrades)) {}
+
+vector<Market> ProtoMarketDataDeserializer::pullMarketOrderBooksMarkets(TimeWindow timeWindow) {
+  return _tradeDataGateway.listMarkets(timeWindow);
+}
+
+vector<Market> ProtoMarketDataDeserializer::pullTradeMarkets(TimeWindow timeWindow) {
+  return _marketOrderBookDataGateway.listMarkets(timeWindow);
+}
+
+vector<MarketOrderBook> ProtoMarketDataDeserializer::pullMarketOrderBooks(Market market, TimeWindow timeWindow) {
+  return _marketOrderBookDataGateway.loadMarket(market, timeWindow);
+}
+
+vector<PublicTrade> ProtoMarketDataDeserializer::pullTrades(Market market, TimeWindow timeWindow) {
+  return _tradeDataGateway.loadMarket(market, timeWindow);
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/src/proto-market-data-serializer.cpp b/src/serialization/src/proto-market-data-serializer.cpp
new file mode 100644
index 00000000..6d826b34
--- /dev/null
+++ b/src/serialization/src/proto-market-data-serializer.cpp
@@ -0,0 +1,59 @@
+#include "proto-market-data-serializer.hpp"
+
+#include <string_view>
+
+#include "marketorderbook.hpp"
+#include "monetaryamount.hpp"
+#include "proto-constants.hpp"
+#include "proto-market-order-book.hpp"
+#include "proto-public-trade.hpp"
+#include "publictrade.hpp"
+#include "serialization-tools.hpp"
+
+namespace cct {
+
+bool ProtoMarketDataSerializer::TradeDataComp::operator()(const ::objects::TradeData& lhs,
+                                                          const ::objects::TradeData& rhs) const {
+  if (lhs.unixtimestampinms() != rhs.unixtimestampinms()) {
+    return lhs.unixtimestampinms() < rhs.unixtimestampinms();
+  }
+  if (lhs.tradeside() != rhs.tradeside()) {
+    return lhs.tradeside() < rhs.tradeside();
+  }
+  MonetaryAmount lhsPrice(lhs.priceamount(), CurrencyCode{}, lhs.pricenbdecimals());
+  MonetaryAmount rhsPrice(rhs.priceamount(), CurrencyCode{}, rhs.pricenbdecimals());
+  if (lhsPrice != rhsPrice) {
+    return lhsPrice < rhsPrice;
+  }
+  MonetaryAmount lhsAmount(lhs.volumeamount(), CurrencyCode{}, lhs.volumenbdecimals());
+  MonetaryAmount rhsAmount(rhs.volumeamount(), CurrencyCode{}, rhs.volumenbdecimals());
+  if (lhsAmount != rhsAmount) {
+    return lhsAmount < rhsAmount;
+  }
+  return false;
+}
+
+bool ProtoMarketDataSerializer::TradeDataEqual::operator()(const ::objects::TradeData& lhs,
+                                                           const ::objects::TradeData& rhs) const {
+  return lhs.unixtimestampinms() == rhs.unixtimestampinms() && lhs.tradeside() == rhs.tradeside() &&
+         MonetaryAmount(lhs.priceamount(), CurrencyCode{}, lhs.pricenbdecimals()) ==
+             MonetaryAmount(rhs.priceamount(), CurrencyCode{}, rhs.pricenbdecimals()) &&
+         MonetaryAmount(lhs.volumeamount(), CurrencyCode{}, lhs.volumenbdecimals()) ==
+             MonetaryAmount(rhs.volumeamount(), CurrencyCode{}, rhs.volumenbdecimals());
+}
+
+ProtoMarketDataSerializer::ProtoMarketDataSerializer(std::string_view dataDir, std::string_view exchangeName)
+    : _marketOrderBookAccumulator(ComputeSubPath(dataDir, exchangeName, kSubPathMarketOrderBook), 1000),
+      _tradesAccumulator(ComputeSubPath(dataDir, exchangeName, kSubPathTrades), 5000) {}
+
+void ProtoMarketDataSerializer::push(const MarketOrderBook& marketOrderBook) {
+  _marketOrderBookAccumulator.push(marketOrderBook.market(), CreateMarketOrderBookTimedData(marketOrderBook));
+}
+
+void ProtoMarketDataSerializer::push(std::span<const PublicTrade> publicTrades) {
+  for (const auto& publicTrade : publicTrades) {
+    _tradesAccumulator.push(publicTrade.market(), CreateTradeData(publicTrade));
+  }
+}
+
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/src/proto-market-order-book.cpp b/src/serialization/src/proto-market-order-book.cpp
new file mode 100644
index 00000000..c8052795
--- /dev/null
+++ b/src/serialization/src/proto-market-order-book.cpp
@@ -0,0 +1,67 @@
+#include "proto-market-order-book.hpp"
+
+#include <chrono>
+#include <ratio>
+
+#include "market-order-book-timed-data.pb.h"
+#include "marketorderbook.hpp"
+#include "monetaryamount.hpp"
+#include "timedef.hpp"
+#include "volumeandpricenbdecimals.hpp"
+
+namespace cct {
+::objects::MarketOrderBookTimedData CreateMarketOrderBookTimedData(const MarketOrderBook& marketOrderBook) {
+  ::objects::MarketOrderBookTimedData protoObj;
+
+  const auto volAndPriNbDecimals = marketOrderBook.volAndPriNbDecimals();
+  const auto unixTimestampInMs = TimestampToMs(marketOrderBook.time());
+
+  protoObj.set_unixtimestampinms(unixTimestampInMs);
+  protoObj.set_volumenbdecimals(volAndPriNbDecimals.volNbDecimals);
+  protoObj.set_pricenbdecimals(volAndPriNbDecimals.priNbDecimals);
+
+  auto& orderBook = *protoObj.mutable_orderbook();
+
+  const auto priNbDecimals = protoObj.pricenbdecimals();
+  const auto volNbDecimals = protoObj.volumenbdecimals();
+
+  const int nbBids = marketOrderBook.nbBidPrices();
+  for (int bidPos = 1; bidPos <= nbBids; ++bidPos) {
+    auto [price, volume] = marketOrderBook[-bidPos];
+    auto& pricedVolume = *orderBook.add_bids();
+
+    pricedVolume.set_price(price.amount(priNbDecimals).value());
+    pricedVolume.set_volume(volume.amount(volNbDecimals).value());
+  }
+
+  const int nbAsks = marketOrderBook.nbAskPrices();
+  for (int askPos = 1; askPos <= nbAsks; ++askPos) {
+    auto [price, volume] = marketOrderBook[askPos];
+    auto& pricedVolume = *orderBook.add_asks();
+
+    pricedVolume.set_price(price.amount(priNbDecimals).value());
+    pricedVolume.set_volume(volume.amount(volNbDecimals).value());
+  }
+
+  return protoObj;
+}
+
+MarketOrderBook MarketOrderBookConverter::operator()(
+    const ::objects::MarketOrderBookTimedData& marketOrderBookTimedData) {
+  const TimePoint timeStamp(std::chrono::milliseconds(marketOrderBookTimedData.unixtimestampinms()));
+  const VolAndPriNbDecimals volAndPriNbDecimals(marketOrderBookTimedData.volumenbdecimals(),
+                                                marketOrderBookTimedData.pricenbdecimals());
+  _orderBookLines.clear();
+  for (const auto& bid : marketOrderBookTimedData.orderbook().bids()) {
+    _orderBookLines.emplace_back(MonetaryAmount(bid.volume(), _market.base(), volAndPriNbDecimals.volNbDecimals),
+                                 MonetaryAmount(bid.price(), _market.quote(), volAndPriNbDecimals.priNbDecimals),
+                                 OrderBookLine::Type::kBid);
+  }
+  for (const auto& ask : marketOrderBookTimedData.orderbook().asks()) {
+    _orderBookLines.emplace_back(MonetaryAmount(ask.volume(), _market.base(), volAndPriNbDecimals.volNbDecimals),
+                                 MonetaryAmount(ask.price(), _market.quote(), volAndPriNbDecimals.priNbDecimals),
+                                 OrderBookLine::Type::kAsk);
+  }
+  return MarketOrderBook{timeStamp, _market, _orderBookLines, volAndPriNbDecimals};
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/src/proto-public-trade.cpp b/src/serialization/src/proto-public-trade.cpp
new file mode 100644
index 00000000..85eb2021
--- /dev/null
+++ b/src/serialization/src/proto-public-trade.cpp
@@ -0,0 +1,49 @@
+#include "proto-public-trade.hpp"
+
+#include "monetaryamount.hpp"
+#include "publictrade.hpp"
+#include "timedef.hpp"
+#include "trade-data.pb.h"
+#include "tradeside.hpp"
+#include "unreachable.hpp"
+
+namespace cct {
+namespace {
+::objects::TradeSide ProtobufTradeSide(TradeSide tradeSide) {
+  switch (tradeSide) {
+    case TradeSide::kBuy:
+      return ::objects::TRADE_BUY;
+    case TradeSide::kSell:
+      return ::objects::TRADE_SELL;
+    default:
+      unreachable();
+  }
+}
+}  // namespace
+
+::objects::TradeData CreateTradeData(const PublicTrade &publicTrade) {
+  ::objects::TradeData protoObj;
+
+  protoObj.set_unixtimestampinms(TimestampToMs(publicTrade.time()));
+
+  protoObj.set_priceamount(publicTrade.price().amount());
+  protoObj.set_pricenbdecimals(publicTrade.price().nbDecimals());
+
+  protoObj.set_volumeamount(publicTrade.amount().amount());
+  protoObj.set_volumenbdecimals(publicTrade.amount().nbDecimals());
+
+  protoObj.set_tradeside(ProtobufTradeSide(publicTrade.side()));
+
+  return protoObj;
+}
+
+PublicTrade PublicTradeConverter::operator()(const ::objects::TradeData &tradeData) const {
+  const TradeSide tradeSide =
+      tradeData.tradeside() == ::objects::TradeSide::TRADE_BUY ? TradeSide::kBuy : TradeSide::kSell;
+  const MonetaryAmount amount(tradeData.volumeamount(), _market.base(), tradeData.volumenbdecimals());
+  const MonetaryAmount price(tradeData.priceamount(), _market.quote(), tradeData.pricenbdecimals());
+  const TimePoint timeStamp(TimeInMs(tradeData.unixtimestampinms()));
+
+  return {tradeSide, amount, price, timeStamp};
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/src/serialization-tools.cpp b/src/serialization/src/serialization-tools.cpp
new file mode 100644
index 00000000..0dee96d9
--- /dev/null
+++ b/src/serialization/src/serialization-tools.cpp
@@ -0,0 +1,17 @@
+#include "serialization-tools.hpp"
+
+#include <string>
+#include <string_view>
+
+namespace cct {
+std::string ComputeSubPath(std::string_view dataDir, std::string_view exchangeName,
+                           std::string_view protobufObjectName) {
+  std::string ret(dataDir);
+  ret.append("/serialized/");
+  ret.append(protobufObjectName);
+  ret.push_back('/');
+  ret.append(exchangeName);
+  ret.push_back('/');
+  return ret;
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/serialization/test/proto-market-accumulator_test.cpp b/src/serialization/test/proto-market-accumulator_test.cpp
new file mode 100644
index 00000000..7b243ad7
--- /dev/null
+++ b/src/serialization/test/proto-market-accumulator_test.cpp
@@ -0,0 +1 @@
+#include <gtest/gtest.h>
\ No newline at end of file
diff --git a/src/serialization/test/proto-multiple-messages-handler_test.cpp b/src/serialization/test/proto-multiple-messages-handler_test.cpp
new file mode 100644
index 00000000..031ba0d4
--- /dev/null
+++ b/src/serialization/test/proto-multiple-messages-handler_test.cpp
@@ -0,0 +1,121 @@
+#include "proto-multiple-messages-handler.hpp"
+
+#include <gtest/gtest.h>
+
+#include <sstream>
+#include <type_traits>
+
+#include "proto-public-trade.hpp"
+#include "publictrade.hpp"
+#include "trade-data.pb.h"
+
+namespace cct {
+class ProtobufMessagesTest : public ::testing::Test {
+ protected:
+  ProtobufMessagesWriter<std::stringstream> writer;
+
+  TimePoint tp1{TimeInMs{std::numeric_limits<int64_t>::max() / 10000000}};
+  TimePoint tp2{TimeInMs{std::numeric_limits<int64_t>::max() / 9000000}};
+  TimePoint tp3{TimeInMs{std::numeric_limits<int64_t>::max() / 8000000}};
+
+  Market market{"ETH", "USDT"};
+  PublicTradeConverter publicTradeConverter{market};
+
+  PublicTrade pt1{TradeSide::kBuy, MonetaryAmount{"0.13", "ETH"}, MonetaryAmount{"1500.5", "USDT"}, tp1};
+  PublicTrade pt2{TradeSide::kSell, MonetaryAmount{"3.7", "ETH"}, MonetaryAmount{"1500.5", "USDT"}, tp2};
+  PublicTrade pt3{TradeSide::kBuy, MonetaryAmount{"0.004", "ETH"}, MonetaryAmount{1501, "USDT"}, tp3};
+
+  ::objects::TradeData td1{CreateTradeData(pt1)};
+  ::objects::TradeData td2{CreateTradeData(pt2)};
+  ::objects::TradeData td3{CreateTradeData(pt3)};
+};
+
+TEST_F(ProtobufMessagesTest, WriteReadSingle) {
+  writer.open(std::stringstream{});
+  writer.write(td1);
+
+  std::stringstream ss = writer.flush();
+
+  ProtobufMessagesReader reader{ss};
+
+  int nbObjectsRead = 0;
+
+  while (reader.hasNext()) {
+    ::objects::TradeData nextObj = reader.next<::objects::TradeData>();
+    PublicTrade pt = publicTradeConverter(nextObj);
+
+    EXPECT_EQ(pt, pt1);
+    ++nbObjectsRead;
+  }
+  EXPECT_EQ(nbObjectsRead, 1);
+}
+
+TEST_F(ProtobufMessagesTest, WriteRead2Flushes) {
+  writer.open(std::stringstream{});
+  writer.write(td1);
+  std::stringstream ss1 = writer.flush();
+
+  writer.open(std::stringstream{});
+  writer.write(td2);
+  std::stringstream ss2 = writer.flush();
+
+  ProtobufMessagesReader reader1{ss1};
+
+  int nbObjectsRead = 0;
+
+  while (reader1.hasNext()) {
+    auto nextObj = reader1.next<::objects::TradeData>();
+    PublicTrade pt = publicTradeConverter(nextObj);
+
+    EXPECT_EQ(pt, pt1);
+    ++nbObjectsRead;
+  }
+  EXPECT_EQ(nbObjectsRead, 1);
+
+  ProtobufMessagesReader reader2{ss2};
+
+  while (reader2.hasNext()) {
+    auto nextObj = reader2.next<::objects::TradeData>();
+    PublicTrade pt = publicTradeConverter(nextObj);
+
+    EXPECT_EQ(pt, pt2);
+    ++nbObjectsRead;
+  }
+  EXPECT_EQ(nbObjectsRead, 2);
+}
+
+TEST_F(ProtobufMessagesTest, WriteReadSeveral) {
+  writer.open(std::stringstream{});
+  writer.write(td1);
+  writer.write(td2);
+  writer.write(td3);
+
+  std::stringstream ss = writer.flush();
+
+  ProtobufMessagesReader reader{ss};
+
+  int nbObjectsRead = 0;
+
+  while (reader.hasNext()) {
+    ::objects::TradeData nextObj = reader.next<::objects::TradeData>();
+    PublicTrade pt = publicTradeConverter(nextObj);
+
+    switch (nbObjectsRead) {
+      case 0:
+        EXPECT_EQ(pt, pt1);
+        break;
+      case 1:
+        EXPECT_EQ(pt, pt2);
+        break;
+      case 2:
+        EXPECT_EQ(pt, pt3);
+        break;
+      default:
+        break;
+    }
+
+    ++nbObjectsRead;
+  }
+  EXPECT_EQ(nbObjectsRead, 3);
+}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/tech/include/durationstring.hpp b/src/tech/include/durationstring.hpp
index 0c1b7a0d..04133d0c 100644
--- a/src/tech/include/durationstring.hpp
+++ b/src/tech/include/durationstring.hpp
@@ -6,6 +6,11 @@
 #include "timedef.hpp"
 
 namespace cct {
+
+/// Check if 'str' starts with a Duration.
+/// Returns the duration string length (0 if no duration detected)
+int DurationLen(std::string_view str);
+
 /// Parse given string representation of a duration and return the duration.
 /// Amounts and units may be separated by spaces. For example:
 /// "1h45min" is allowed, as well as "1h 45min" and "1 h 45      min "
diff --git a/src/tech/src/durationstring.cpp b/src/tech/src/durationstring.cpp
index ace2c46b..297935af 100644
--- a/src/tech/src/durationstring.cpp
+++ b/src/tech/src/durationstring.cpp
@@ -3,7 +3,9 @@
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
+#include <iostream>
 #include <string_view>
+#include <system_error>
 
 #include "cct_cctype.hpp"
 #include "cct_invalid_argument_exception.hpp"
@@ -12,7 +14,55 @@
 #include "timedef.hpp"
 
 namespace cct {
+
+namespace {
+constexpr std::pair<std::string_view, Duration> kDurationUnits[] = {
+    {"y", std::chrono::years(1)},   {"mon", std::chrono::months(1)},      {"w", std::chrono::weeks(1)},
+    {"d", std::chrono::days(1)},    {"h", std::chrono::hours(1)},         {"min", std::chrono::minutes(1)},
+    {"s", std::chrono::seconds(1)}, {"ms", std::chrono::milliseconds(1)}, {"us", std::chrono::microseconds(1)},
+};
+}
+
+int DurationLen(std::string_view str) {
+  const std::size_t sz = str.size();
+  if (sz == 0) {
+    return 0;
+  }
+  std::size_t charPos = 0;
+  while (charPos < sz && isspace(str[charPos])) {
+    ++charPos;
+  }
+  int value{};
+  const auto [ptr, err] = std::from_chars(str.data() + charPos, str.data() + str.size(), value);
+  if (err != std::errc() || value <= 0) {
+    return 0;
+  }
+  charPos = ptr - str.data();
+
+  while (charPos < sz && isspace(str[charPos])) {
+    ++charPos;
+  }
+  const std::size_t first = charPos;
+  while (charPos < sz && islower(str[charPos])) {
+    ++charPos;
+  }
+  const std::string_view timeUnitStr(str.begin() + first, str.begin() + charPos);
+
+  const auto it = std::ranges::find_if(kDurationUnits, [timeUnitStr](const auto &durationUnitWithDuration) {
+    return durationUnitWithDuration.first == timeUnitStr;
+  });
+  if (it == std::end(kDurationUnits)) {
+    return 0;
+  }
+  // There is a substring with size 'charPos' that represents a duration
+  return charPos + DurationLen(str.substr(charPos));
+}
+
 Duration ParseDuration(std::string_view durationStr) {
+  while (!durationStr.empty() && isspace(durationStr.front())) {
+    durationStr.remove_prefix(1);
+  }
+
   if (durationStr.empty()) {
     throw invalid_argument("Empty duration is not allowed");
   }
@@ -27,7 +77,7 @@ Duration ParseDuration(std::string_view durationStr) {
   const std::size_t sz = durationStr.size();
   Duration ret{};
   for (std::size_t charPos = 0; charPos < sz;) {
-    std::size_t intFirst = charPos;
+    const std::size_t intFirst = charPos;
 
     while (charPos < sz && isdigit(durationStr[charPos])) {
       ++charPos;
@@ -35,38 +85,24 @@ Duration ParseDuration(std::string_view durationStr) {
     if (intFirst == charPos) {
       throw invalid_argument(kInvalidTimeDurationUnitMsg);
     }
-    std::string_view timeAmountStr(durationStr.begin() + intFirst, durationStr.begin() + charPos);
-    int64_t timeAmount = FromString<int64_t>(timeAmountStr);
+    const std::string_view timeAmountStr(durationStr.begin() + intFirst, durationStr.begin() + charPos);
+    const int64_t timeAmount = FromString<int64_t>(timeAmountStr);
 
     while (charPos < sz && isspace(durationStr[charPos])) {
       ++charPos;
     }
-    std::size_t unitFirst = charPos;
+    const std::size_t unitFirst = charPos;
     while (charPos < sz && islower(durationStr[charPos])) {
       ++charPos;
     }
-    std::string_view timeUnitStr(durationStr.begin() + unitFirst, durationStr.begin() + charPos);
-    if (timeUnitStr == "y") {
-      ret += std::chrono::years(timeAmount);
-    } else if (timeUnitStr == "mon") {
-      ret += std::chrono::months(timeAmount);
-    } else if (timeUnitStr == "w") {
-      ret += std::chrono::weeks(timeAmount);
-    } else if (timeUnitStr == "d") {
-      ret += std::chrono::days(timeAmount);
-    } else if (timeUnitStr == "h") {
-      ret += std::chrono::hours(timeAmount);
-    } else if (timeUnitStr == "min") {
-      ret += std::chrono::minutes(timeAmount);
-    } else if (timeUnitStr == "s") {
-      ret += std::chrono::seconds(timeAmount);
-    } else if (timeUnitStr == "ms") {
-      ret += std::chrono::milliseconds(timeAmount);
-    } else if (timeUnitStr == "us") {
-      ret += std::chrono::microseconds(timeAmount);
-    } else {
+    const std::string_view timeUnitStr(durationStr.begin() + unitFirst, durationStr.begin() + charPos);
+    const auto it = std::ranges::find_if(kDurationUnits, [timeUnitStr](const auto &durationUnitWithDuration) {
+      return durationUnitWithDuration.first == timeUnitStr;
+    });
+    if (it == std::end(kDurationUnits)) {
       throw invalid_argument(kInvalidTimeDurationUnitMsg);
     }
+    ret += timeAmount * it->second;
     while (charPos < sz && isspace(durationStr[charPos])) {
       ++charPos;
     }
@@ -78,7 +114,8 @@ Duration ParseDuration(std::string_view durationStr) {
 template <class TimeUnitT>
 void AdjustWithUnit(std::string_view unitStr, Duration &dur, string &ret) {
   if (dur >= TimeUnitT(1)) {
-    auto nU = std::chrono::duration_cast<TimeUnitT>(dur).count();
+    const auto nU = std::chrono::duration_cast<TimeUnitT>(dur).count();
+
     AppendString(ret, nU);
     ret += unitStr;
     dur -= TimeUnitT(nU);
diff --git a/src/tech/test/durationstring_test.cpp b/src/tech/test/durationstring_test.cpp
index bc67ae94..94adafd4 100644
--- a/src/tech/test/durationstring_test.cpp
+++ b/src/tech/test/durationstring_test.cpp
@@ -9,6 +9,20 @@
 
 namespace cct {
 
+TEST(DurationLen, Basic) { EXPECT_EQ(DurationLen("99min"), 5); }
+
+TEST(DurationLen, BasicComplex) { EXPECT_EQ(DurationLen("34d45min"), 8); }
+
+TEST(DurationLen, BasicWithComma) { EXPECT_EQ(DurationLen("23s,bithumb"), 3); }
+
+TEST(DurationLen, ComplexWithSpaces) { EXPECT_EQ(DurationLen(" 1 d 52 h,kraken"), 9); }
+
+TEST(DurationLen, NegativeValue) { EXPECT_EQ(DurationLen("-3sec"), 0); }
+
+TEST(DurationLen, InvalidTimeUnit) { EXPECT_EQ(DurationLen("63po"), 0); }
+
+TEST(DurationLen, DoesNotStartWithNumber) { EXPECT_EQ(DurationLen("us"), 0); }
+
 TEST(ParseDuration, EmptyDurationNotAllowed) { EXPECT_THROW(ParseDuration(""), invalid_argument); }
 
 TEST(ParseDuration, DurationDays) { EXPECT_EQ(ParseDuration("37d"), std::chrono::days(37)); }
diff --git a/src/trading/CMakeLists.txt b/src/trading/CMakeLists.txt
new file mode 100644
index 00000000..09446901
--- /dev/null
+++ b/src/trading/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory(common)
\ No newline at end of file
diff --git a/src/trading/common/CMakeLists.txt b/src/trading/common/CMakeLists.txt
new file mode 100644
index 00000000..d5c502bd
--- /dev/null
+++ b/src/trading/common/CMakeLists.txt
@@ -0,0 +1,7 @@
+aux_source_directory(src TRADING_SRC)
+
+add_library(coincenter_trading-common STATIC ${TRADING_SRC})
+target_link_libraries(coincenter_trading-common PUBLIC coincenter_api-objects)
+target_link_libraries(coincenter_trading-common PUBLIC coincenter_objects)
+target_link_libraries(coincenter_trading-common PUBLIC coincenter_tech)
+target_include_directories(coincenter_trading-common PUBLIC include)
\ No newline at end of file
diff --git a/src/trading/common/include/abstract-market-trader.hpp b/src/trading/common/include/abstract-market-trader.hpp
new file mode 100644
index 00000000..a8579630
--- /dev/null
+++ b/src/trading/common/include/abstract-market-trader.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <span>
+#include <string_view>
+
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+#include "trader-command.hpp"
+
+namespace cct {
+class AbstractMarketTrader {
+ public:
+  explicit AbstractMarketTrader(std::string_view name) noexcept;
+
+  virtual ~AbstractMarketTrader() = default;
+
+  virtual TraderCommand trade(std::span<const MarketOrderBook> marketOrderBooks,
+                              std::span<const PublicTrade> trades) = 0;
+
+  std::string_view name() const { return _name; }
+
+ private:
+  std::string_view _name;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/trading/common/include/dummy-market-trader.hpp b/src/trading/common/include/dummy-market-trader.hpp
new file mode 100644
index 00000000..c85f50fb
--- /dev/null
+++ b/src/trading/common/include/dummy-market-trader.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <span>
+
+#include "abstract-market-trader.hpp"
+#include "marketorderbook.hpp"
+#include "publictrade.hpp"
+#include "trader-command.hpp"
+
+namespace cct {
+class DummyMarketTrader : public AbstractMarketTrader {
+ public:
+  DummyMarketTrader() noexcept : AbstractMarketTrader("dummy-trader") {}
+
+  TraderCommand trade([[maybe_unused]] std::span<const MarketOrderBook> marketOrderBooks,
+                      [[maybe_unused]] std::span<const PublicTrade> trades) override {
+    return TraderCommand{};
+  }
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/trading/common/include/market-trader-engine.hpp b/src/trading/common/include/market-trader-engine.hpp
new file mode 100644
index 00000000..04a3d8b0
--- /dev/null
+++ b/src/trading/common/include/market-trader-engine.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "abstract-market-trader.hpp"
+#include "exchangeprivateapitypes.hpp"
+#include "market.hpp"
+#include "marketorderbook.hpp"
+
+namespace cct {
+class MarketTraderEngine {
+ public:
+  MarketTraderEngine(Market market, AbstractMarketTrader &marketTrader);
+
+  void trade(std::span<const MarketOrderBook> marketOrderBooks, std::span<const PublicTrade> trades);
+
+  void finalizeAndComputeGainsAndLosses();
+
+ private:
+  void matchOpenedOrdersWith(const MarketOrderBook &marketOrderBook);
+
+  Market _market;
+  MarketOrderBook _lastMarketOrderBook;
+  AbstractMarketTrader &_marketTrader;
+  Orders _openedOrders;
+  ClosedOrders _closedOrders;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/trading/common/include/trader-command.hpp b/src/trading/common/include/trader-command.hpp
new file mode 100644
index 00000000..3764193a
--- /dev/null
+++ b/src/trading/common/include/trader-command.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <cstdint>
+
+#include "priceoptionsdef.hpp"
+#include "tradeside.hpp"
+
+namespace cct {
+class TraderCommand {
+ public:
+  enum class Type : int8_t { kWait, kPlace };
+
+  TraderCommand() noexcept = default;
+
+  explicit TraderCommand(TradeSide tradeSide, PriceStrategy priceStrategy = PriceStrategy::kMaker)
+      : _type(Type::kPlace), _tradeSide(tradeSide), _priceStrategy(priceStrategy) {}
+
+  Type type() const { return _type; }
+
+  TradeSide tradeSide() const { return _tradeSide; }
+
+  PriceStrategy priceStrategy() const { return _priceStrategy; }
+
+ private:
+  Type _type = Type::kWait;
+  TradeSide _tradeSide = TradeSide::kBuy;
+  PriceStrategy _priceStrategy = PriceStrategy::kMaker;
+};
+}  // namespace cct
\ No newline at end of file
diff --git a/src/trading/common/src/abstract-market-trader.cpp b/src/trading/common/src/abstract-market-trader.cpp
new file mode 100644
index 00000000..44018487
--- /dev/null
+++ b/src/trading/common/src/abstract-market-trader.cpp
@@ -0,0 +1,5 @@
+#include "abstract-market-trader.hpp"
+
+namespace cct {
+AbstractMarketTrader::AbstractMarketTrader(std::string_view name) noexcept : _name(name) {}
+}  // namespace cct
\ No newline at end of file
diff --git a/src/trading/common/src/market-trader-engine.cpp b/src/trading/common/src/market-trader-engine.cpp
new file mode 100644
index 00000000..52cd2d90
--- /dev/null
+++ b/src/trading/common/src/market-trader-engine.cpp
@@ -0,0 +1,42 @@
+#include "market-trader-engine.hpp"
+
+#include <algorithm>
+
+#include "marketorderbook.hpp"
+#include "monetaryamount.hpp"
+
+namespace cct {
+MarketTraderEngine::MarketTraderEngine(Market market, AbstractMarketTrader &marketTrader)
+    : _market(market), _marketTrader(marketTrader) {}
+
+void MarketTraderEngine::trade(std::span<const MarketOrderBook> marketOrderBooks, std::span<const PublicTrade> trades) {
+  log::info(" trade {} market order books and {} trades", marketOrderBooks.size(), trades.size());
+
+  _marketTrader.trade(marketOrderBooks, trades);
+}
+
+void MarketTraderEngine::finalizeAndComputeGainsAndLosses() {}
+
+void MarketTraderEngine::matchOpenedOrdersWith(const MarketOrderBook &marketOrderBook) {
+  SmallVector<Order, 1> newlyClosedOrders;
+  for (Order &order : _openedOrders) {
+    const auto matchedParts = marketOrderBook.computeMatchedParts(order.side(), order.remainingVolume(), order.price());
+
+    for (const auto &[price, amount] : matchedParts) {
+      _closedOrders.emplace_back(order.id(), amount, price, marketOrderBook.time(), order.side());
+
+      if (order.remainingVolume() == amount) {
+        newlyClosedOrders.push_back(order);
+      } else {
+        order = Order(order.id(), order.matchedVolume() + amount, order.remainingVolume() - amount, order.price(),
+                      order.placedTime(), order.side());
+      }
+    }
+  }
+  const auto [first, last] = std::ranges::remove_if(_openedOrders, [&newlyClosedOrders](const Order &order) {
+    return std::ranges::any_of(newlyClosedOrders,
+                               [&order](const auto &newlyClosedOrder) { return order.id() == newlyClosedOrder.id(); });
+  });
+  _openedOrders.erase(first, last);
+}
+}  // namespace cct
\ No newline at end of file