Here's a concise Git commit message summarizing the changes in the provided diff.txt file:

123-hub-afk · 123-hub-afk · commit 9664264717e7 · 2025-06-13T20:22:35.000+03:00
---

**Commit message:**

```
Refactor strategy logic and improve configurability

- Updated `Strategy` class to accept external config (window size, bin count, allowed asset hash)
- Replaced `size_t` with `HashT` in action callbacks for better type consistency
- Enhanced logging with decomposed hash details for buy/sell operations
- Modified MI calculator to use `HashT` for asset identifiers
- Corrected `TradingPairToSmallStringView` to use fully qualified enum type and underlying type
- Added example40 to CMake build system
```

---

Let me know if you want to tailor it to a specific style (e.g. conventional commits, Jira ticket references, etc.).
diff --git a/aos/converters/trading_pair_to_small_string_view/trading_pair_to_small_string_view.h b/aos/converters/trading_pair_to_small_string_view/trading_pair_to_small_string_view.h
@@ -8,8 +8,8 @@ namespace aos {
 namespace impl {
 // Хэш-таблица для конвертации торговой пары в строку
 class TradingPairToSmallStringView {
-    constexpr static std::array<std::pair<TradingPair, std::string_view>,
-                                static_cast<std::size_t>(TradingPair::kCount)>
+    constexpr static std::array<std::pair<aos::TradingPair, std::string_view>,
+                                static_cast<std::underlying_type_t<aos::TradingPair>>(aos::TradingPair::kCount)>
         dictionary_ = {{
             {TradingPair::kBTCUSDT, "btcusdt"},
             {TradingPair::kETHUSDT, "ethusdt"},
diff --git a/aos/mutual_information/c_mutual_information_calculator.h b/aos/mutual_information/c_mutual_information_calculator.h
@@ -75,7 +75,7 @@ class MutualInformationCalculator
 
     std::pair<bool, T> ComputeMutualInformation(
         SlidingWindowStorageAvgDevMinMaxInterface<HashT, T>& window_storage,
-        size_t hash_asset, size_t paired_asset, int bins) const override {
+        HashT hash_asset, HashT paired_asset, int bins) const override {
         // Проверяем, есть ли достаточно данных для обоих активов
         if (!window_storage.HasEnoughData(hash_asset) ||
             !window_storage.HasEnoughData(paired_asset)) {
diff --git a/aos/strategies/deviation_and_mutual_info/c_strategy.h b/aos/strategies/deviation_and_mutual_info/c_strategy.h
@@ -8,6 +8,9 @@
 #include "aos/sliding_window_storage/c_sliding_window_storage.h"
 #include "aos/strategy/i_strategy.h"
 #include "aos/strategy/strategy.h"
+#include "aos/strategies/deviation_and_mutual_info/config.h"
+#include "aos/hash_utils/decompose_hash.h"
+#include "fmtlog.h"
 
 namespace aos {
 namespace strategies {
@@ -18,34 +21,33 @@ class Strategy : public StrategyInterface<HashT, T>{
     impl::SlidingWindowStorageAvgDevMinMax<HashT, T> sliding_window_;
     impl::MutualInformationCalculator<HashT, T> mi_calculator_;
     MarketTripletManagerInterface<HashT>& market_triplet_manager_;
-
+    const Config<HashT>& config_;
   private:
     void InitBuyActions() {
         core_strategy_.AddActionsToBuy(
-            [](std::queue<size_t>& queue, size_t hash, const double& value) {
-                if (hash == 1) {
+            [this](std::queue<HashT>& queue, HashT hash, const T& value) {
+                if (hash == config_.allowed_asset_hash) {
                     logi("start analise hash:{} value:{}", hash, value);
                     queue.push(hash);
                 }
             });
 
-        core_strategy_.AddActionsToBuy([this](std::queue<size_t>& queue, size_t hash,
-                                        const double& value) {
+        core_strategy_.AddActionsToBuy([this](std::queue<HashT>& queue, HashT hash,
+                                        const T& value) {
             auto [_, ratio] = sliding_window_.GetDeviationRatio(hash, value);
-            auto dev        = sliding_window_.GetDeviation(hash, value);
-            logi("Buy: hash:{} value:{} dev:{} ratio:{}", hash, value, dev,
-                 ratio);
+            auto [status_deviation, dev]        = sliding_window_.GetDeviation(hash, value);
+            logi("Buy: hash:{} value:{} dev:{} ratio:{}", hash, value, dev, ratio);
             if (ratio > 0.001) {
                 queue.push(hash);
             }
         });
 
-        core_strategy_.AddActionsToBuy([this](std::queue<size_t>& queue, size_t hash,
-                                        const double& value) {
+        core_strategy_.AddActionsToBuy([this](std::queue<HashT>& queue, HashT hash,
+                                        const T& value) {
             if (!market_triplet_manager_.HasPair(hash)) return;
             for (const auto& pair : market_triplet_manager_.GetPairs(hash)) {
                 auto [status, mi] = mi_calculator_.ComputeMutualInformation(
-                    sliding_window_, hash, pair, 10);
+                    sliding_window_, hash, pair, config_.number_bins);
                 if (status && mi > 2) {
                     logi("Buy MI ({} <-> {}): {}", hash, pair, mi);
                     queue.push(pair);
@@ -54,36 +56,44 @@ class Strategy : public StrategyInterface<HashT, T>{
         });
 
         core_strategy_.AddActionsToBuy(
-            [](std::queue<size_t>& queue, size_t hash, const double& value) {
-                logi("Need buy hash:{} value:{}", hash, value);
+            [](std::queue<HashT>& queue, HashT hash, const T& value) {
+                common::ExchangeId exchange_id_1 = common::ExchangeId::kInvalid;
+                aos::NetworkEnvironment network_environment_1;
+                aos::CategoryRaw category_market_1;
+                aos::TradingPair trading_pair_1;
+                aos::DecomposeHash(hash, exchange_id_1, category_market_1,
+                                network_environment_1, trading_pair_1);
+                logi("need buy with hash={} with value={} on {} category={} {} {}",
+                    hash, value, exchange_id_1, category_market_1, network_environment_1,
+                    trading_pair_1);
             });
     };
     void InitSellActions() {
         core_strategy_.AddActionsToSell(
-            [](std::queue<size_t>& queue, size_t hash, const double& value) {
-                if (hash == 1) {
+            [this](std::queue<HashT>& queue, HashT hash, const T& value) {
+                if (hash == config_.allowed_asset_hash) {
                     logi("start analise hash:{} value:{}", hash, value);
                     queue.push(hash);
                 }
             });
 
-        core_strategy_.AddActionsToSell([this](std::queue<size_t>& queue, size_t hash,
-                                         const double& value) {
+        core_strategy_.AddActionsToSell([this](std::queue<HashT>& queue, HashT hash,
+                                         const T& value) {
             auto [_, ratio] = sliding_window_.GetDeviationRatio(hash, value);
-            auto dev        = sliding_window_.GetDeviation(hash, value);
+            auto [status_deviation, dev]        = sliding_window_.GetDeviation(hash, value);
             logi("Sell: hash:{} value:{} dev:{} ratio:{}", hash, value, dev,
                  ratio);
             if (ratio < 0.001) {
                 queue.push(hash);
             }
         });
 
-        core_strategy_.AddActionsToSell([this](std::queue<size_t>& queue, size_t hash,
-                                         const double& value) {
+        core_strategy_.AddActionsToSell([this](std::queue<HashT>& queue, HashT hash,
+                                         const T& value) {
             if (!market_triplet_manager_.HasPair(hash)) return;
             for (const auto& pair : market_triplet_manager_.GetPairs(hash)) {
                 auto [status, mi] = mi_calculator_.ComputeMutualInformation(
-                    sliding_window_, hash, pair, 10);
+                    sliding_window_, hash, pair, config_.number_bins);
                 if (status && mi > 2) {
                     logi("Sell MI ({} <-> {}): {}", hash, pair, mi);
                     queue.push(pair);
@@ -92,15 +102,24 @@ class Strategy : public StrategyInterface<HashT, T>{
         });
 
         core_strategy_.AddActionsToSell(
-            [](std::queue<size_t>& queue, size_t hash, const double& value) {
-                logi("Need sell hash:{} value:{}", hash, value);
+            [](std::queue<HashT>& queue, HashT hash, const T& value) {
+                common::ExchangeId exchange_id_1 = common::ExchangeId::kInvalid;
+                aos::NetworkEnvironment network_environment_1;
+                aos::CategoryRaw category_market_1;
+                aos::TradingPair trading_pair_1;
+                aos::DecomposeHash(hash, exchange_id_1, category_market_1,
+                                network_environment_1, trading_pair_1);
+                logi("need sell with hash={} with value={} on {} category={} {} {}",
+                    hash, value, exchange_id_1, category_market_1, network_environment_1,
+                    trading_pair_1);
             });
     }
 
   public:
-    Strategy(int window_size, MarketTripletManagerInterface<HashT>& market_triplet_manager) :
-     sliding_window_(window_size),
-     market_triplet_manager_(market_triplet_manager) {
+    Strategy(MarketTripletManagerInterface<HashT>& market_triplet_manager, const Config<HashT>& config) :
+     sliding_window_(config.window_size),
+     market_triplet_manager_(market_triplet_manager),
+     config_(config) {
         InitBuyActions();
         InitSellActions();
     }
diff --git a/aos/strategies/deviation_and_mutual_info/config.h b/aos/strategies/deviation_and_mutual_info/config.h
@@ -0,0 +1,20 @@
+#pragma once
+#include <cstdint>
+
+
+namespace aos {
+namespace strategies {
+namespace deviation_and_mutual_information {
+template <typename HashT>
+struct Config{
+    const uint32_t window_size;
+    const uint32_t number_bins;
+    const HashT allowed_asset_hash;
+    // constexpr-конструктор
+    constexpr Config(uint32_t new_window_size, uint32_t new_number_bins, HashT new_allowed_asset_hash)
+        : window_size(new_window_size), number_bins(new_number_bins), allowed_asset_hash(new_allowed_asset_hash) {}
+ 
+};
+};
+};
+};
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -32,4 +32,5 @@ add_subdirectory(example35)
 add_subdirectory(example36)
 add_subdirectory(example37)
 add_subdirectory(example38)
-add_subdirectory(example39)
+add_subdirectory(example39)
+add_subdirectory(example40)
diff --git a/examples/example40/CMakeLists.txt b/examples/example40/CMakeLists.txt
@@ -0,0 +1,37 @@
+
+set (PROJECT_NAME example40)
+project(${PROJECT_NAME})
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg")
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg")
+SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
+
+file(GLOB SRC
+     "*.cpp"
+)
+
+
+add_executable (${PROJECT_NAME}
+    ${SRC}
+)
+
+target_link_libraries(${PROJECT_NAME}
+aos
+magic_enum::magic_enum
+tomlplusplus::tomlplusplus
+sodium
+concurrentqueue
+nlohmann_json::nlohmann_json
+fmt
+fmtlog-static
+)
+
+set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 23)
+
+option(ENABLE_SANITIZERS "Enable AddressSanitizer and LeakSanitizer" ON)
+
+if (ENABLE_SANITIZERS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,leak -fno-omit-frame-pointer -g")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address,leak")
+endif()
diff --git a/examples/example40/main.cpp b/examples/example40/main.cpp
@@ -0,0 +1,46 @@
+#include <boost/asio.hpp>
+
+#include "aos/aos.h"
+#include "aos/sliding_window_storage/c_sliding_window_storage.h"
+#include "aos/mutual_information/c_mutual_information_calculator.h"
+#include "aos/strategies/deviation_and_mutual_info/c_strategy.h"
+#include "aoe/binance/hash_utils/hash_utils.h"
+#include "aoe/bybit/hash_utils/hash_utils.h"
+#include "fmtlog.h"
+
+int main() {
+    {
+        using HashT = uint64_t;
+        using Price = double;
+        using Qty   = double;
+        using namespace aos::impl;
+        MarketTripletManagerDefault<HashT> market_triplet_manager;
+        const auto binance_btc_usdt = aoe::binance::HashKey(aoe::binance::Category::kSpot, aos::NetworkEnvironment::kMainNet, aos::TradingPair::kBTCUSDT);  
+        const auto bybit_btc_usdt = aoe::bybit::HashKey(aoe::bybit::Category::kSpot, aos::NetworkEnvironment::kMainNet, aos::TradingPair::kBTCUSDT);  
+        market_triplet_manager.Connect(binance_btc_usdt, bybit_btc_usdt);
+
+        boost::asio::thread_pool thread_pool;
+        
+        constexpr aos::strategies::deviation_and_mutual_information::Config<HashT> config{
+            5,
+            10,
+            binance_btc_usdt 
+        };
+        aos::strategies::deviation_and_mutual_information::Strategy<HashT, Price> strategy(market_triplet_manager, config);
+        
+        StrategyEngineDefault<HashT, Price> strategy_engine(
+            thread_pool, strategy);
+        std::vector<std::pair<double, double>> incoming_data = {
+            {29300.25, 29290.10}, {29350.50, 29340.35}, {29400.75, 29380.20},
+            {29450.00, 29430.15}, {29500.25, 29488.05}, {29550.50, 29520.40},
+            {29602.75, 29560.60}, {29000.00, 29600.50}, {49700.25, 29650.40},
+            {29750.50, 59700.35}};
+        for (uint64_t i = 0; i < incoming_data.size(); ++i) {
+            strategy_engine.AddData(binance_btc_usdt, incoming_data[i].first);
+            strategy_engine.AddData(bybit_btc_usdt, incoming_data[i].second);
+        }
+        strategy_engine.Wait();
+    }
+    fmtlog::poll();
+    return 0;
+}
