diff --git a/core/api/service/impl/api_service_impl.cpp b/core/api/service/impl/api_service_impl.cpp
index 41f02ffd83..eb8c5608f8 100644
--- a/core/api/service/impl/api_service_impl.cpp
+++ b/core/api/service/impl/api_service_impl.cpp
@@ -515,7 +515,7 @@ namespace kagome::api {
   void ApiServiceImpl::onStorageEvent(SubscriptionSetId set_id,
                                       SessionPtr &session,
                                       const Buffer &key,
-                                      const Buffer &data,
+                                      const std::optional<Buffer> &data,
                                       const common::Hash256 &block) {
     sendEvent(server_,
               session,
diff --git a/core/api/service/impl/api_service_impl.hpp b/core/api/service/impl/api_service_impl.hpp
index 5b54a93681..df8eaa27bc 100644
--- a/core/api/service/impl/api_service_impl.hpp
+++ b/core/api/service/impl/api_service_impl.hpp
@@ -197,7 +197,7 @@ namespace kagome::api {
     void onStorageEvent(SubscriptionSetId set_id,
                         SessionPtr &session,
                         const Buffer &key,
-                        const Buffer &data,
+                        const std::optional<Buffer> &data,
                         const common::Hash256 &block);
     void onChainEvent(SubscriptionSetId set_id,
                       SessionPtr &session,
diff --git a/core/consensus/grandpa/impl/voting_round_impl.cpp b/core/consensus/grandpa/impl/voting_round_impl.cpp
index 9ac3d349e2..68a88cd50c 100644
--- a/core/consensus/grandpa/impl/voting_round_impl.cpp
+++ b/core/consensus/grandpa/impl/voting_round_impl.cpp
@@ -1229,7 +1229,9 @@ namespace kagome::consensus::grandpa {
       return false;
     }
 
-    BOOST_ASSERT(prevote_ghost_.has_value());
+    if (not prevote_ghost_) {
+      return false;
+    }
     const auto &prevote_ghost = prevote_ghost_.value();
 
     // anything new finalized? finalized blocks are those which have both
diff --git a/core/host_api/impl/host_api_factory_impl.cpp b/core/host_api/impl/host_api_factory_impl.cpp
index 20b09d2c8e..7929ba4565 100644
--- a/core/host_api/impl/host_api_factory_impl.cpp
+++ b/core/host_api/impl/host_api_factory_impl.cpp
@@ -11,7 +11,6 @@ namespace kagome::host_api {
 
   HostApiFactoryImpl::HostApiFactoryImpl(
       const OffchainExtensionConfig &offchain_config,
-      std::shared_ptr<storage::changes_trie::ChangesTracker> tracker,
       std::shared_ptr<crypto::Sr25519Provider> sr25519_provider,
       std::shared_ptr<crypto::EcdsaProvider> ecdsa_provider,
       std::shared_ptr<crypto::Ed25519Provider> ed25519_provider,
@@ -23,7 +22,6 @@ namespace kagome::host_api {
           offchain_persistent_storage,
       std::shared_ptr<offchain::OffchainWorkerPool> offchain_worker_pool)
       : offchain_config_(offchain_config),
-        changes_tracker_{std::move(tracker)},
         sr25519_provider_(std::move(sr25519_provider)),
         ecdsa_provider_(std::move(ecdsa_provider)),
         ed25519_provider_(std::move(ed25519_provider)),
@@ -33,7 +31,6 @@ namespace kagome::host_api {
         bip39_provider_(std::move(bip39_provider)),
         offchain_persistent_storage_(std::move(offchain_persistent_storage)),
         offchain_worker_pool_(std::move(offchain_worker_pool)) {
-    BOOST_ASSERT(changes_tracker_ != nullptr);
     BOOST_ASSERT(sr25519_provider_ != nullptr);
     BOOST_ASSERT(ed25519_provider_ != nullptr);
     BOOST_ASSERT(secp256k1_provider_ != nullptr);
@@ -52,7 +49,6 @@ namespace kagome::host_api {
                                          memory_provider,
                                          core_provider,
                                          storage_provider,
-                                         changes_tracker_,
                                          sr25519_provider_,
                                          ecdsa_provider_,
                                          ed25519_provider_,
diff --git a/core/host_api/impl/host_api_factory_impl.hpp b/core/host_api/impl/host_api_factory_impl.hpp
index 71afb34616..0dad9ea206 100644
--- a/core/host_api/impl/host_api_factory_impl.hpp
+++ b/core/host_api/impl/host_api_factory_impl.hpp
@@ -16,7 +16,6 @@
 #include "crypto/secp256k1_provider.hpp"
 #include "crypto/sr25519_provider.hpp"
 #include "host_api/impl/offchain_extension.hpp"
-#include "storage/changes_trie/changes_tracker.hpp"
 
 namespace kagome::offchain {
   class OffchainPersistentStorage;
@@ -31,7 +30,6 @@ namespace kagome::host_api {
 
     HostApiFactoryImpl(
         const OffchainExtensionConfig &offchain_config,
-        std::shared_ptr<storage::changes_trie::ChangesTracker> tracker,
         std::shared_ptr<crypto::Sr25519Provider> sr25519_provider,
         std::shared_ptr<crypto::EcdsaProvider> ecdsa_provider,
         std::shared_ptr<crypto::Ed25519Provider> ed25519_provider,
@@ -51,7 +49,6 @@ namespace kagome::host_api {
 
    private:
     OffchainExtensionConfig offchain_config_;
-    std::shared_ptr<storage::changes_trie::ChangesTracker> changes_tracker_;
     std::shared_ptr<crypto::Sr25519Provider> sr25519_provider_;
     std::shared_ptr<crypto::EcdsaProvider> ecdsa_provider_;
     std::shared_ptr<crypto::Ed25519Provider> ed25519_provider_;
diff --git a/core/host_api/impl/host_api_impl.cpp b/core/host_api/impl/host_api_impl.cpp
index 3e806e65f8..c83e60f339 100644
--- a/core/host_api/impl/host_api_impl.cpp
+++ b/core/host_api/impl/host_api_impl.cpp
@@ -23,7 +23,6 @@ namespace kagome::host_api {
       std::shared_ptr<const runtime::MemoryProvider> memory_provider,
       std::shared_ptr<const runtime::CoreApiFactory> core_provider,
       std::shared_ptr<runtime::TrieStorageProvider> storage_provider,
-      std::shared_ptr<storage::changes_trie::ChangesTracker> tracker,
       std::shared_ptr<const crypto::Sr25519Provider> sr25519_provider,
       std::shared_ptr<const crypto::EcdsaProvider> ecdsa_provider,
       std::shared_ptr<const crypto::Ed25519Provider> ed25519_provider,
@@ -56,7 +55,7 @@ namespace kagome::host_api {
                   hasher,
                   memory_provider_,
                   std::move(core_provider)},
-        storage_ext_(storage_provider_, memory_provider_, std::move(tracker)),
+        storage_ext_(storage_provider_, memory_provider_),
         child_storage_ext_(storage_provider_, memory_provider_),
         offchain_ext_(offchain_config,
                       memory_provider_,
diff --git a/core/host_api/impl/host_api_impl.hpp b/core/host_api/impl/host_api_impl.hpp
index 32ea77117a..aa40b074f2 100644
--- a/core/host_api/impl/host_api_impl.hpp
+++ b/core/host_api/impl/host_api_impl.hpp
@@ -38,7 +38,6 @@ namespace kagome::host_api {
         std::shared_ptr<const runtime::MemoryProvider> memory_provider,
         std::shared_ptr<const runtime::CoreApiFactory> core_provider,
         std::shared_ptr<runtime::TrieStorageProvider> storage_provider,
-        std::shared_ptr<storage::changes_trie::ChangesTracker> tracker,
         std::shared_ptr<const crypto::Sr25519Provider> sr25519_provider,
         std::shared_ptr<const crypto::EcdsaProvider> ecdsa_provider,
         std::shared_ptr<const crypto::Ed25519Provider> ed25519_provider,
diff --git a/core/host_api/impl/storage_extension.cpp b/core/host_api/impl/storage_extension.cpp
index 129b85c585..5c5d9900b3 100644
--- a/core/host_api/impl/storage_extension.cpp
+++ b/core/host_api/impl/storage_extension.cpp
@@ -22,8 +22,6 @@
 using kagome::common::Buffer;
 
 namespace {
-  const auto CHANGES_CONFIG_KEY = kagome::common::Buffer{}.put(":changes_trie");
-
   [[nodiscard]] kagome::storage::trie::StateVersion toStateVersion(
       kagome::runtime::WasmI32 state_version_int) {
     if (state_version_int == 0) {
@@ -42,15 +40,12 @@ namespace {
 namespace kagome::host_api {
   StorageExtension::StorageExtension(
       std::shared_ptr<runtime::TrieStorageProvider> storage_provider,
-      std::shared_ptr<const runtime::MemoryProvider> memory_provider,
-      std::shared_ptr<storage::changes_trie::ChangesTracker> changes_tracker)
+      std::shared_ptr<const runtime::MemoryProvider> memory_provider)
       : storage_provider_(std::move(storage_provider)),
         memory_provider_(std::move(memory_provider)),
-        changes_tracker_{std::move(changes_tracker)},
         logger_{log::createLogger("StorageExtension", "storage_extension")} {
     BOOST_ASSERT_MSG(storage_provider_ != nullptr, "storage batch is nullptr");
     BOOST_ASSERT_MSG(memory_provider_ != nullptr, "memory provider is nullptr");
-    BOOST_ASSERT_MSG(changes_tracker_ != nullptr, "changes tracker is nullptr");
   }
 
   void StorageExtension::reset() {
@@ -254,20 +249,9 @@ namespace kagome::host_api {
 
   runtime::WasmSpan StorageExtension::ext_storage_changes_root_version_1(
       runtime::WasmSpan parent_hash_data) {
-    auto parent_hash_span = runtime::PtrSize(parent_hash_data);
     auto &memory = memory_provider_->getCurrentMemory()->get();
-    auto parent_hash_bytes =
-        memory.loadN(parent_hash_span.ptr, parent_hash_span.size);
-    common::Hash256 parent_hash;
-    std::copy_n(parent_hash_bytes.begin(),
-                common::Hash256::size(),
-                parent_hash.begin());
-
-    auto &&result = calcStorageChangesRoot(parent_hash);
-    auto &&res = result.has_value()
-                     ? std::make_optional(std::move(result.value()))
-                     : std::nullopt;
-    return memory.storeBuffer(scale::encode(std::move(res)).value());
+    // https://github.com/paritytech/substrate/pull/10080
+    return memory.storeBuffer(scale::encode(std::optional<Buffer>()).value());
   }
 
   runtime::WasmSpan StorageExtension::ext_storage_next_key_version_1(
@@ -452,47 +436,6 @@ namespace kagome::host_api {
     return runtime::PtrSize(res).ptr;
   }
 
-  std::optional<common::Buffer> StorageExtension::calcStorageChangesRoot(
-      common::Hash256 parent_hash) const {
-    if (not storage_provider_->tryGetPersistentBatch()) {
-      logger_->error("ext_storage_changes_root persistent batch not found");
-      return std::nullopt;
-    }
-    auto batch = storage_provider_->tryGetPersistentBatch().value();
-    auto config_bytes_res = batch->tryGet(CHANGES_CONFIG_KEY);
-    if (config_bytes_res.has_error()) {
-      logger_->error("ext_storage_changes_root resulted with an error: {}",
-                     config_bytes_res.error().message());
-      throw std::runtime_error(config_bytes_res.error().message());
-    }
-    if (config_bytes_res.value() == std::nullopt) {
-      return std::nullopt;
-    }
-    auto config_res = scale::decode<storage::changes_trie::ChangesTrieConfig>(
-        config_bytes_res.value().value().get());
-    if (config_res.has_error()) {
-      logger_->error("ext_storage_changes_root resulted with an error: {}",
-                     config_res.error().message());
-      throw std::runtime_error(config_res.error().message());
-    }
-    storage::changes_trie::ChangesTrieConfig trie_config = config_res.value();
-
-    SL_DEBUG(logger_,
-             "ext_storage_changes_root constructing changes trie with "
-             "parent_hash: {}",
-             parent_hash.toHex());
-    auto trie_hash_res =
-        changes_tracker_->constructChangesTrie(parent_hash, trie_config);
-    if (trie_hash_res.has_error()) {
-      logger_->error("ext_storage_changes_root resulted with an error: {}",
-                     trie_hash_res.error().message());
-      throw std::runtime_error(trie_hash_res.error().message());
-    }
-    common::Buffer result_buf(trie_hash_res.value());
-    SL_TRACE_FUNC_CALL(logger_, result_buf, parent_hash);
-    return result_buf;
-  }
-
   runtime::WasmSpan StorageExtension::clearPrefix(
       common::BufferView prefix, std::optional<uint32_t> limit) {
     auto batch = storage_provider_->getCurrentBatch();
diff --git a/core/host_api/impl/storage_extension.hpp b/core/host_api/impl/storage_extension.hpp
index 9033dbbf6e..98014ef8c8 100644
--- a/core/host_api/impl/storage_extension.hpp
+++ b/core/host_api/impl/storage_extension.hpp
@@ -10,7 +10,6 @@
 
 #include "log/logger.hpp"
 #include "runtime/types.hpp"
-#include "storage/changes_trie/changes_tracker.hpp"
 #include "storage/trie/serialization/polkadot_codec.hpp"
 
 namespace kagome::runtime {
@@ -26,8 +25,7 @@ namespace kagome::host_api {
    public:
     StorageExtension(
         std::shared_ptr<runtime::TrieStorageProvider> storage_provider,
-        std::shared_ptr<const runtime::MemoryProvider> memory_provider,
-        std::shared_ptr<storage::changes_trie::ChangesTracker> changes_tracker);
+        std::shared_ptr<const runtime::MemoryProvider> memory_provider);
 
     void reset();
 
@@ -163,9 +161,6 @@ namespace kagome::host_api {
     outcome::result<std::optional<common::Buffer>> getStorageNextKey(
         const common::Buffer &key) const;
 
-    std::optional<common::Buffer> calcStorageChangesRoot(
-        common::Hash256 parent) const;
-
     runtime::WasmSpan clearPrefix(common::BufferView prefix,
                                   std::optional<uint32_t> limit);
 
@@ -177,7 +172,6 @@ namespace kagome::host_api {
 
     std::shared_ptr<runtime::TrieStorageProvider> storage_provider_;
     std::shared_ptr<const runtime::MemoryProvider> memory_provider_;
-    std::shared_ptr<storage::changes_trie::ChangesTracker> changes_tracker_;
     storage::trie::PolkadotCodec codec_;
     log::Logger logger_;
 
diff --git a/core/primitives/digest.hpp b/core/primitives/digest.hpp
index bbca039751..c399811c9d 100644
--- a/core/primitives/digest.hpp
+++ b/core/primitives/digest.hpp
@@ -13,7 +13,6 @@
 #include "common/unused.hpp"
 #include "primitives/scheduled_change.hpp"
 #include "scale/scale.hpp"
-#include "storage/changes_trie/changes_trie_config.hpp"
 
 namespace kagome::primitives {
   /// Consensus engine unique ID.
@@ -31,38 +30,6 @@ namespace kagome::primitives {
   inline const auto kUnsupportedEngineId_BEEF =
       ConsensusEngineId::fromString("BEEF").value();
 
-  /// System digest item that contains the root of changes trie at given
-  /// block. It is created for every block iff runtime supports changes
-  /// trie creation.
-  struct ChangesTrieRoot : public common::Hash256 {};
-
-  // TODO (kamilsa): workaround unless we bump gtest version to 1.8.1+
-  // after gtest update use `data` type directly
-  struct ChangesTrieSignal {
-    boost::variant<std::optional<storage::changes_trie::ChangesTrieConfig>>
-        data;
-
-    bool operator==(const ChangesTrieSignal &rhs) const {
-      return data == rhs.data;
-    }
-
-    bool operator!=(const ChangesTrieSignal &rhs) const {
-      return !operator==(rhs);
-    }
-  };
-
-  template <class Stream,
-            typename = std::enable_if_t<Stream::is_encoder_stream>>
-  Stream &operator<<(Stream &s, const ChangesTrieSignal &sig) {
-    return s << sig.data;
-  }
-
-  template <class Stream,
-            typename = std::enable_if_t<Stream::is_decoder_stream>>
-  Stream &operator>>(Stream &s, ChangesTrieSignal &sig) {
-    return s >> sig.data;
-  }
-
   struct Other : public common::Buffer {};
 
   namespace detail {
@@ -220,12 +187,12 @@ namespace kagome::primitives {
   /// https://github.com/paritytech/substrate/blob/polkadot-v0.9.12/primitives/runtime/src/generic/digest.rs#L272
   using DigestItem = boost::variant<Other,                       // 0
                                     Unused<1>,                   // 1
-                                    ChangesTrieRoot,             // 2
+                                    Unused<2>,                   // 2
                                     Unused<3>,                   // 3
                                     Consensus,                   // 4
                                     Seal,                        // 5
                                     PreRuntime,                  // 6
-                                    ChangesTrieSignal,           // 7
+                                    Unused<7>,                   // 7
                                     RuntimeEnvironmentUpdated>;  // 8
 
   /**
diff --git a/core/primitives/event_types.hpp b/core/primitives/event_types.hpp
index 95ee4f4681..825d84a2de 100644
--- a/core/primitives/event_types.hpp
+++ b/core/primitives/event_types.hpp
@@ -216,7 +216,7 @@ namespace kagome::primitives::events {
   using StorageSubscriptionEngine =
       subscription::SubscriptionEngine<common::Buffer,
                                        std::shared_ptr<api::Session>,
-                                       common::Buffer,
+                                       std::optional<common::Buffer>,
                                        primitives::BlockHash>;
   using StorageSubscriptionEnginePtr =
       std::shared_ptr<StorageSubscriptionEngine>;
diff --git a/core/runtime/runtime_api/impl/core.cpp b/core/runtime/runtime_api/impl/core.cpp
index ee877f7d6d..bffd3bc176 100644
--- a/core/runtime/runtime_api/impl/core.cpp
+++ b/core/runtime/runtime_api/impl/core.cpp
@@ -36,8 +36,7 @@ namespace kagome::runtime {
       const primitives::Block &block) {
     OUTCOME_TRY(parent, header_repo_->getBlockHeader(block.header.parent_hash));
     BOOST_ASSERT(parent.number == block.header.number - 1);
-    OUTCOME_TRY(changes_tracker_->onBlockExecutionStart(
-        block.header.parent_hash, parent.number));
+    changes_tracker_->onBlockExecutionStart(block.header.parent_hash);
     OUTCOME_TRY(executor_->persistentCallAt<void>(
         block.header.parent_hash, "Core_execute_block", block));
     return outcome::success();
@@ -45,9 +44,7 @@ namespace kagome::runtime {
 
   outcome::result<storage::trie::RootHash> CoreImpl::initialize_block(
       const primitives::BlockHeader &header) {
-    OUTCOME_TRY(changes_tracker_->onBlockExecutionStart(
-        header.parent_hash,
-        header.number - 1));  // parent's number
+    changes_tracker_->onBlockExecutionStart(header.parent_hash);
     const auto res = executor_->persistentCallAt<void>(
         header.parent_hash, "Core_initialize_block", header);
     if (res.has_value()) {
diff --git a/core/storage/changes_trie/CMakeLists.txt b/core/storage/changes_trie/CMakeLists.txt
index c5881b2df5..8c4803a9ce 100644
--- a/core/storage/changes_trie/CMakeLists.txt
+++ b/core/storage/changes_trie/CMakeLists.txt
@@ -3,7 +3,6 @@
 
 add_library(changes_tracker
     impl/storage_changes_tracker_impl.cpp
-    impl/changes_trie.cpp
     )
 target_link_libraries(changes_tracker
     buffer
diff --git a/core/storage/changes_trie/changes_tracker.hpp b/core/storage/changes_trie/changes_tracker.hpp
index 185c8f42a6..91605bfd99 100644
--- a/core/storage/changes_trie/changes_tracker.hpp
+++ b/core/storage/changes_trie/changes_tracker.hpp
@@ -3,8 +3,6 @@
 
 #include "common/buffer.hpp"
 #include "primitives/common.hpp"
-#include "primitives/extrinsic.hpp"
-#include "storage/changes_trie/changes_trie_config.hpp"
 
 namespace kagome::storage::changes_trie {
 
@@ -21,42 +19,27 @@ namespace kagome::storage::changes_trie {
     /**
      * Supposed to be called when a block execution starts
      */
-    virtual outcome::result<void> onBlockExecutionStart(
-        primitives::BlockHash new_parent_hash,
-        primitives::BlockNumber new_parent_number) = 0;
+    virtual void onBlockExecutionStart(
+        primitives::BlockHash new_parent_hash) = 0;
 
     /**
      * Supposed to be called when an entry is put into the tracked storage
      * @arg new_entry states whether the entry is new, or just an update of a
      * present value
      */
-    virtual outcome::result<void> onPut(common::BufferView extrinsic_index,
-                                        const common::BufferView &key,
-                                        const common::BufferView &value,
-                                        bool new_entry) = 0;
+    virtual void onPut(const common::BufferView &key,
+                       const common::BufferView &value,
+                       bool new_entry) = 0;
 
     /**
      * Supposed to be called when a block is added to the block tree.
      */
     virtual void onBlockAdded(const primitives::BlockHash &hash) = 0;
 
-    /**
-     * Supposed to be called when clear by prefix called.
-     */
-    virtual void onClearPrefix(const common::BufferView &prefix) = 0;
-
     /**
      * Supposed to be called when an entry is removed from the tracked storage
      */
-    virtual outcome::result<void> onRemove(common::BufferView extrinsic_index,
-                                           const common::BufferView &key) = 0;
-
-    /**
-     * Sinks accumulated changes for the latest registered block to the changes
-     * trie and returns its root hash
-     */
-    virtual outcome::result<common::Hash256> constructChangesTrie(
-        const primitives::BlockHash &parent, const ChangesTrieConfig &conf) = 0;
+    virtual void onRemove(const common::BufferView &key) = 0;
   };
 
 }  // namespace kagome::storage::changes_trie
diff --git a/core/storage/changes_trie/changes_trie_config.hpp b/core/storage/changes_trie/changes_trie_config.hpp
deleted file mode 100644
index 8377bcec77..0000000000
--- a/core/storage/changes_trie/changes_trie_config.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Copyright Soramitsu Co., Ltd. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#ifndef KAGOME_STORAGE_CHANGES_TRIE_CHANGES_TRIE_CONFIG
-#define KAGOME_STORAGE_CHANGES_TRIE_CHANGES_TRIE_CONFIG
-
-#include <cstdint>
-
-namespace kagome::storage::changes_trie {
-  /// https://github.com/paritytech/substrate/blob/polkadot-v0.9.8/primitives/core/src/changes_trie.rs#L28
-  struct ChangesTrieConfig {
-    /**
-     * The interval (in blocks) at which
-     * block mappings are created. Block mappings are not created when this is
-     * less or equal to 1.
-     */
-    uint32_t digest_interval;
-
-    /**
-     * Maximal number of levels in the
-     * hierarchy. 0 means that block mappings are not created at
-     * all. 1 means only the regular digest_interval block
-     * mappings are created. Any other level means that the block mappings are
-     * created every (digest_interval in power of digest_levels) block for
-     * each level in 1 to digest_levels.
-     */
-    uint32_t digest_levels;
-
-    bool operator==(const ChangesTrieConfig &rhs) const {
-      return digest_interval == rhs.digest_interval
-             and digest_levels == rhs.digest_levels;
-    }
-
-    bool operator!=(const ChangesTrieConfig &rhs) const {
-      return !operator==(rhs);
-    }
-  };
-
-  /**
-   * @brief scale-encodes blob instance to stream
-   * @tparam Stream output stream type
-   * @tparam size blob size
-   * @param s output stream reference
-   * @param blob value to encode
-   * @return reference to stream
-   */
-  template <class Stream,
-            typename = std::enable_if_t<Stream::is_encoder_stream>>
-  Stream &operator<<(Stream &s, const ChangesTrieConfig &config) {
-    return s << config.digest_interval << config.digest_levels;
-  }
-
-  /**
-   * @brief decodes blob instance from stream
-   * @tparam Stream output stream type
-   * @tparam size blob size
-   * @param s input stream reference
-   * @param blob value to encode
-   * @return reference to stream
-   */
-  template <class Stream,
-            typename = std::enable_if_t<Stream::is_decoder_stream>>
-  Stream &operator>>(Stream &s, ChangesTrieConfig &config) {
-    return s >> config.digest_interval >> config.digest_levels;
-  }
-}  // namespace kagome::storage::changes_trie
-
-#endif  // KAGOME_STORAGE_CHANGES_TRIE_CHANGES_TRIE_CONFIG
diff --git a/core/storage/changes_trie/impl/changes_trie.cpp b/core/storage/changes_trie/impl/changes_trie.cpp
deleted file mode 100644
index 889bec59ff..0000000000
--- a/core/storage/changes_trie/impl/changes_trie.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * Copyright Soramitsu Co., Ltd. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include "storage/changes_trie/impl/changes_trie.hpp"
-
-#include "scale/scale.hpp"
-
-namespace kagome::storage::changes_trie {
-
-  outcome::result<std::unique_ptr<ChangesTrie>> ChangesTrie::buildFromChanges(
-      const primitives::BlockNumber &parent_number,
-      const std::shared_ptr<storage::trie::PolkadotTrieFactory> &trie_factory,
-      std::shared_ptr<storage::trie::Codec> codec,
-      const ExtrinsicsChanges &extinsics_changes,
-      const ChangesTrieConfig &config) {
-    BOOST_ASSERT(trie_factory != nullptr);
-    auto changes_storage = trie_factory->createEmpty();
-
-    for (auto &change : extinsics_changes) {
-      auto &key = change.first;
-      auto &changers = change.second;
-      auto current_number = parent_number + 1;
-      KeyIndexVariant keyIndex{ExtrinsicsChangesKey{{current_number, key}}};
-      OUTCOME_TRY(key_enc, scale::encode(keyIndex));
-      OUTCOME_TRY(value, scale::encode(changers));
-      common::Buffer value_buf{std::move(value)};
-      OUTCOME_TRY(changes_storage->put(common::Buffer{std::move(key_enc)},
-                                       std::move(value_buf)));
-    }
-
-    return std::unique_ptr<ChangesTrie>{
-        new ChangesTrie{std::move(changes_storage), std::move(codec)}};
-  }
-
-  ChangesTrie::ChangesTrie(std::unique_ptr<storage::trie::PolkadotTrie> trie,
-                           std::shared_ptr<storage::trie::Codec> codec)
-      : changes_trie_{std::move(trie)},
-        codec_{std::move(codec)},
-        logger_(log::createLogger("ChangesTrie", "changes_trie")) {
-    BOOST_ASSERT(changes_trie_ != nullptr);
-    BOOST_ASSERT(codec_ != nullptr);
-  }
-
-  common::Hash256 ChangesTrie::getHash() const {
-    if (changes_trie_ == nullptr) {
-      return {};
-    }
-
-    auto root = changes_trie_->getRoot();
-    if (root == nullptr) {
-      logger_->warn("Get root of empty changes trie");
-      return codec_->hash256(common::Buffer{0});
-    }
-    auto enc_res = codec_->encodeNode(*root);
-    if (enc_res.has_error()) {
-      logger_->error("Encoding Changes trie failed"
-                     + enc_res.error().message());
-      return {};
-    }
-    auto hash_bytes = codec_->hash256(enc_res.value());
-    return hash_bytes;
-  }
-
-}  // namespace kagome::storage::changes_trie
diff --git a/core/storage/changes_trie/impl/changes_trie.hpp b/core/storage/changes_trie/impl/changes_trie.hpp
deleted file mode 100644
index bbb5e43a78..0000000000
--- a/core/storage/changes_trie/impl/changes_trie.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * Copyright Soramitsu Co., Ltd. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#ifndef KAGOME_CORE_STORAGE_CHANGES_TRIE_IMPL_CHANGES_TRIE
-#define KAGOME_CORE_STORAGE_CHANGES_TRIE_IMPL_CHANGES_TRIE
-
-#include <map>
-
-#include <boost/variant.hpp>
-
-#include "blockchain/block_header_repository.hpp"
-#include "common/buffer.hpp"
-#include "log/logger.hpp"
-#include "primitives/common.hpp"
-#include "primitives/extrinsic.hpp"
-#include "storage/changes_trie/changes_trie_config.hpp"
-#include "storage/trie/codec.hpp"
-#include "storage/trie/polkadot_trie/polkadot_trie_factory.hpp"
-
-namespace kagome::storage::changes_trie {
-
-  class ChangesTrie {
-   public:
-    using ExtrinsicsChanges = std::map<common::Buffer,
-                                       std::vector<primitives::ExtrinsicIndex>,
-                                       std::less<>>;
-
-    static outcome::result<std::unique_ptr<ChangesTrie>> buildFromChanges(
-        const primitives::BlockNumber &parent_block,
-        const std::shared_ptr<storage::trie::PolkadotTrieFactory> &trie_factory,
-        std::shared_ptr<trie::Codec> codec,
-        const ExtrinsicsChanges &extinsics_changes,
-        const ChangesTrieConfig &config);
-
-    common::Hash256 getHash() const;
-
-   private:
-    ChangesTrie(std::unique_ptr<trie::PolkadotTrie> trie,
-                std::shared_ptr<trie::Codec> codec);
-
-    /**
-     * key of a changes trie
-     */
-    struct KeyIndex {
-      // block in which the change occurred
-      primitives::BlockNumber block;
-      // changed key
-      common::Buffer key;
-    };
-    // Mapping between storage key and extrinsics
-    struct ExtrinsicsChangesKey : public KeyIndex {};
-    // Mapping between storage key and blocks
-    struct BlocksChangesKey : public KeyIndex {};
-    //  Mapping between storage key and child changes Trie
-    struct ChildChangesKey : public KeyIndex {};
-
-    // the key used for the Changes Trie must be the varying datatype, not the
-    // individual, appended KeyIndex.
-    using KeyIndexVariant = boost::variant<Unused<0>,
-                                           ExtrinsicsChangesKey,
-                                           BlocksChangesKey,
-                                           ChildChangesKey>;
-
-    template <class Stream,
-              typename = std::enable_if_t<Stream::is_encoder_stream>>
-    friend Stream &operator<<(Stream &s, const KeyIndex &b) {
-      return s << b.block << b.key;
-    }
-    template <class Stream,
-              typename = std::enable_if_t<Stream::is_decoder_stream>>
-    friend Stream &operator>>(Stream &s, KeyIndex &b) {
-      return s >> b.block >> b.key;
-    }
-
-    std::unique_ptr<trie::PolkadotTrie> changes_trie_;
-    std::shared_ptr<trie::Codec> codec_;
-    log::Logger logger_;
-  };
-
-}  // namespace kagome::storage::changes_trie
-
-#endif  // KAGOME_CORE_STORAGE_CHANGES_TRIE_IMPL_CHANGES_TRIE
diff --git a/core/storage/changes_trie/impl/storage_changes_tracker_impl.cpp b/core/storage/changes_trie/impl/storage_changes_tracker_impl.cpp
index 71b01d2d3b..2a903aa4aa 100644
--- a/core/storage/changes_trie/impl/storage_changes_tracker_impl.cpp
+++ b/core/storage/changes_trie/impl/storage_changes_tracker_impl.cpp
@@ -1,51 +1,23 @@
 #include "storage/changes_trie/impl/storage_changes_tracker_impl.hpp"
 
-#include "runtime/common/storage_code_provider.hpp"
-#include "scale/scale.hpp"
-#include "storage/changes_trie/impl/changes_trie.hpp"
 #include "storage/predefined_keys.hpp"
 
-OUTCOME_CPP_DEFINE_CATEGORY(kagome::storage::changes_trie,
-                            StorageChangesTrackerImpl::Error,
-                            e) {
-  using E = kagome::storage::changes_trie::StorageChangesTrackerImpl::Error;
-  switch (e) {
-    case E::INVALID_PARENT_HASH:
-      return "The supplied parent hash doesn't match the one of the current "
-             "block";
-  }
-  return "Unknown error";
-}
-
 namespace kagome::storage::changes_trie {
 
   StorageChangesTrackerImpl::StorageChangesTrackerImpl(
-      std::shared_ptr<storage::trie::PolkadotTrieFactory> trie_factory,
-      std::shared_ptr<storage::trie::Codec> codec,
       primitives::events::StorageSubscriptionEnginePtr
           storage_subscription_engine,
       primitives::events::ChainSubscriptionEnginePtr chain_subscription_engine)
-      : trie_factory_(std::move(trie_factory)),
-        codec_(std::move(codec)),
-        parent_number_{std::numeric_limits<primitives::BlockNumber>::max()},
-        storage_subscription_engine_(std::move(storage_subscription_engine)),
+      : storage_subscription_engine_(std::move(storage_subscription_engine)),
         chain_subscription_engine_(std::move(chain_subscription_engine)),
-        logger_{log::createLogger("Storage Changes Tracker", "changes_trie")} {
-    BOOST_ASSERT(trie_factory_ != nullptr);
-    BOOST_ASSERT(codec_ != nullptr);
-  }
+        logger_{log::createLogger("Storage Changes Tracker", "changes_trie")} {}
 
-  outcome::result<void> StorageChangesTrackerImpl::onBlockExecutionStart(
-      primitives::BlockHash new_parent_hash,
-      primitives::BlockNumber new_parent_number) {
+  void StorageChangesTrackerImpl::onBlockExecutionStart(
+      primitives::BlockHash new_parent_hash) {
     parent_hash_ = new_parent_hash;
-    parent_number_ = new_parent_number;
     // new block -- new extrinsics
     actual_val_.clear();
-
-    extrinsics_changes_.clear();
     new_entries_.clear();
-    return outcome::success();
   }
 
   void StorageChangesTrackerImpl::onBlockAdded(
@@ -55,88 +27,37 @@ namespace kagome::storage::changes_trie {
           primitives::events::ChainEventType::kNewRuntime, hash);
     }
     for (auto &pair : actual_val_) {
-      SL_TRACE(logger_,
-               "Key: 0x{}; Value 0x{};",
-               pair.first.toHex(),
-               pair.second.toHex());
+      if (pair.second) {
+        SL_TRACE(logger_, "Key: {:l}; Value {:l};", pair.first, *pair.second);
+      } else {
+        SL_TRACE(logger_, "Key: {:l}; Removed;", pair.first);
+      }
       storage_subscription_engine_->notify(
           pair.first, pair.second, parent_hash_);
     }
   }
 
-  void StorageChangesTrackerImpl::onClearPrefix(
-      const common::BufferView &prefix) {
-    for (auto it = actual_val_.lower_bound(prefix);
-         it != actual_val_.end()
-         && prefix.size() <= static_cast<ssize_t>(it->first.size())
-         && it->first.view(0, prefix.size()) == prefix;
-         ++it) {
-      it->second.clear();
-    }
-  }
-
-  outcome::result<void> StorageChangesTrackerImpl::onPut(
-      common::BufferView extrinsic_index,
-      const common::BufferView &key,
-      const common::BufferView &value,
-      bool is_new_entry) {
-    auto change_it = extrinsics_changes_.find(key);
-    OUTCOME_TRY(idx,
-                scale::decode<primitives::ExtrinsicIndex>(extrinsic_index));
-
-    // if key was already changed in the same block, just add extrinsic to
-    // the changers list
-    if (change_it != extrinsics_changes_.end()) {
-      change_it->second.push_back(idx);
+  void StorageChangesTrackerImpl::onPut(const common::BufferView &key,
+                                        const common::BufferView &value,
+                                        bool is_new_entry) {
+    auto it = actual_val_.find(key);
+    if (it != actual_val_.end()) {
+      it->second.emplace(value);
     } else {
-      extrinsics_changes_.insert(std::make_pair(key, std::vector{idx}));
+      actual_val_.emplace(key, value);
       if (is_new_entry) {
         new_entries_.insert(common::Buffer{key});
       }
     }
-    actual_val_.insert_or_assign(common::Buffer{key}, common::Buffer{value});
-    return outcome::success();
   }
 
-  outcome::result<void> StorageChangesTrackerImpl::onRemove(
-      common::BufferView extrinsic_index, const common::BufferView &key) {
+  void StorageChangesTrackerImpl::onRemove(const common::BufferView &key) {
     if (auto it = actual_val_.find(key); it != actual_val_.end()) {
-      it->second.clear();
-    }
-
-    auto change_it = extrinsics_changes_.find(key);
-    OUTCOME_TRY(idx,
-                scale::decode<primitives::ExtrinsicIndex>(extrinsic_index));
-
-    // if key was already changed in the same block, just add extrinsic to
-    // the changers list
-    if (change_it != extrinsics_changes_.end()) {
-      // if new entry, i.e. it doesn't exist in the persistent storage, then
-      // don't track it, because it's just temporary
-      if (auto i = new_entries_.find(key); i != new_entries_.end()) {
-        extrinsics_changes_.erase(change_it);
-        new_entries_.erase(i);
+      if (new_entries_.erase(it->first) != 0) {
+        actual_val_.erase(it);
       } else {
-        change_it->second.push_back(idx);
+        it->second.reset();
       }
-
-    } else {
-      extrinsics_changes_.insert(std::make_pair(key, std::vector{idx}));
     }
-    return outcome::success();
   }
-
-  outcome::result<common::Hash256>
-  StorageChangesTrackerImpl::constructChangesTrie(
-      const primitives::BlockHash &parent, const ChangesTrieConfig &conf) {
-    if (parent != parent_hash_) {
-      return Error::INVALID_PARENT_HASH;
-    }
-    OUTCOME_TRY(
-        trie,
-        ChangesTrie::buildFromChanges(
-            parent_number_, trie_factory_, codec_, extrinsics_changes_, conf));
-    return trie->getHash();
-  }
-
 }  // namespace kagome::storage::changes_trie
diff --git a/core/storage/changes_trie/impl/storage_changes_tracker_impl.hpp b/core/storage/changes_trie/impl/storage_changes_tracker_impl.hpp
index cfaf9e2169..eb7d4be187 100644
--- a/core/storage/changes_trie/impl/storage_changes_tracker_impl.hpp
+++ b/core/storage/changes_trie/impl/storage_changes_tracker_impl.hpp
@@ -6,63 +6,33 @@
 #include "log/logger.hpp"
 #include "primitives/event_types.hpp"
 
-namespace kagome::storage::trie {
-  class Codec;
-  class PolkadotTrieFactory;
-}  // namespace kagome::storage::trie
-
 namespace kagome::storage::changes_trie {
 
   class StorageChangesTrackerImpl : public ChangesTracker {
    public:
-    enum class Error { INVALID_PARENT_HASH };
-
-    StorageChangesTrackerImpl(
-        std::shared_ptr<storage::trie::PolkadotTrieFactory> trie_factory,
-        std::shared_ptr<storage::trie::Codec> codec,
-        primitives::events::StorageSubscriptionEnginePtr
-            storage_subscription_engine,
-        primitives::events::ChainSubscriptionEnginePtr
-            chain_subscription_engine);
+    StorageChangesTrackerImpl(primitives::events::StorageSubscriptionEnginePtr
+                                  storage_subscription_engine,
+                              primitives::events::ChainSubscriptionEnginePtr
+                                  chain_subscription_engine);
 
-    /**
-     * Functor that returns the current extrinsic index, which is supposed to
-     * be stored in the state trie
-     */
     ~StorageChangesTrackerImpl() override = default;
 
-    outcome::result<void> onBlockExecutionStart(
-        primitives::BlockHash new_parent_hash,
-        primitives::BlockNumber new_parent_number) override;
+    void onBlockExecutionStart(primitives::BlockHash new_parent_hash) override;
 
-    outcome::result<void> onPut(common::BufferView extrinsic_index,
-                                const common::BufferView &key,
-                                const common::BufferView &value,
-                                bool new_entry) override;
+    void onPut(const common::BufferView &key,
+               const common::BufferView &value,
+               bool new_entry) override;
     void onBlockAdded(const primitives::BlockHash &hash) override;
-    void onClearPrefix(const common::BufferView &prefix) override;
-    outcome::result<void> onRemove(common::BufferView extrinsic_index,
-                                   const common::BufferView &key) override;
-
-    outcome::result<common::Hash256> constructChangesTrie(
-        const primitives::BlockHash &parent,
-        const ChangesTrieConfig &conf) override;
+    void onRemove(const common::BufferView &key) override;
 
    private:
-    std::shared_ptr<storage::trie::PolkadotTrieFactory> trie_factory_;
-    std::shared_ptr<storage::trie::Codec> codec_;
-
-    std::map<common::Buffer,
-             std::vector<primitives::ExtrinsicIndex>,
-             std::less<>>
-        extrinsics_changes_;
     std::set<common::Buffer, std::less<>>
         new_entries_;  // entries that do not yet exist in
                        // the underlying storage
-    std::map<common::Buffer, common::Buffer, std::less<>> actual_val_;
+    std::map<common::Buffer, std::optional<common::Buffer>, std::less<>>
+        actual_val_;
 
     primitives::BlockHash parent_hash_;
-    primitives::BlockNumber parent_number_;
     primitives::events::StorageSubscriptionEnginePtr
         storage_subscription_engine_;
     primitives::events::ChainSubscriptionEnginePtr chain_subscription_engine_;
@@ -71,7 +41,4 @@ namespace kagome::storage::changes_trie {
 
 }  // namespace kagome::storage::changes_trie
 
-OUTCOME_HPP_DECLARE_ERROR(kagome::storage::changes_trie,
-                          StorageChangesTrackerImpl::Error);
-
 #endif  // KAGOME_STORAGE_CHANGES_TRIE_STORAGE_CHANGES_TRACKER_IMPL
diff --git a/core/storage/trie/impl/persistent_trie_batch_impl.cpp b/core/storage/trie/impl/persistent_trie_batch_impl.cpp
index 1c4e0450da..ce00bd203b 100644
--- a/core/storage/trie/impl/persistent_trie_batch_impl.cpp
+++ b/core/storage/trie/impl/persistent_trie_batch_impl.cpp
@@ -7,8 +7,6 @@
 
 #include <memory>
 
-#include "scale/scale.hpp"
-#include "storage/predefined_keys.hpp"
 #include "storage/trie/impl/topper_trie_batch_impl.hpp"
 #include "storage/trie/polkadot_trie/polkadot_trie_cursor_impl.hpp"
 #include "storage/trie/polkadot_trie/trie_error.hpp"
@@ -25,10 +23,6 @@ OUTCOME_CPP_DEFINE_CATEGORY(kagome::storage::trie,
 }
 
 namespace kagome::storage::trie {
-  // sometimes there is no extrinsic index for a runtime call
-  const common::Buffer NO_EXTRINSIC_INDEX_VALUE{
-      scale::encode(0xffffffff).value()};
-
   std::unique_ptr<PersistentTrieBatchImpl> PersistentTrieBatchImpl::create(
       std::shared_ptr<Codec> codec,
       std::shared_ptr<TrieSerializer> serializer,
@@ -58,15 +52,6 @@ namespace kagome::storage::trie {
     BOOST_ASSERT(trie_ != nullptr);
   }
 
-  outcome::result<common::BufferConstRef>
-  PersistentTrieBatchImpl::getExtrinsicIndex() const {
-    OUTCOME_TRY(res, trie_->tryGet(kExtrinsicIndexKey));
-    if (res) {
-      return res.value();
-    }
-    return NO_EXTRINSIC_INDEX_VALUE;
-  }
-
   outcome::result<RootHash> PersistentTrieBatchImpl::commit() {
     OUTCOME_TRY(root, serializer_->storeTrie(*trie_));
     SL_TRACE_FUNC_CALL(logger_, root);
@@ -103,13 +88,11 @@ namespace kagome::storage::trie {
   outcome::result<std::tuple<bool, uint32_t>>
   PersistentTrieBatchImpl::clearPrefix(const BufferView &prefix,
                                        std::optional<uint64_t> limit) {
-    if (changes_.has_value()) changes_.value()->onClearPrefix(prefix);
     SL_TRACE_VOID_FUNC_CALL(logger_, prefix);
-    OUTCOME_TRY(ext_idx, getExtrinsicIndex());
     return trie_->clearPrefix(
         prefix, limit, [&](const auto &key, auto &&) -> outcome::result<void> {
           if (changes_.has_value()) {
-            OUTCOME_TRY(changes_.value()->onRemove(ext_idx.get(), key));
+            changes_.value()->onRemove(key);
           }
           return outcome::success();
         });
@@ -121,10 +104,9 @@ namespace kagome::storage::trie {
     bool is_new_entry = not contains;
     auto res = trie_->put(key, value);
     if (res and changes_.has_value()) {
-      OUTCOME_TRY(ext_idx, getExtrinsicIndex());
       SL_TRACE_VOID_FUNC_CALL(logger_, key, value);
-      OUTCOME_TRY(
-          changes_.value()->onPut(ext_idx.get(), key, value, is_new_entry));
+
+      changes_.value()->onPut(key, value, is_new_entry);
     }
     return res;
   }
@@ -136,13 +118,12 @@ namespace kagome::storage::trie {
   }
 
   outcome::result<void> PersistentTrieBatchImpl::remove(const BufferView &key) {
-    auto res = trie_->remove(key);
-    if (res and changes_.has_value()) {
+    OUTCOME_TRY(trie_->remove(key));
+    if (changes_.has_value()) {
       SL_TRACE_VOID_FUNC_CALL(logger_, key);
-      OUTCOME_TRY(ext_idx, getExtrinsicIndex());
-      OUTCOME_TRY(changes_.value()->onRemove(ext_idx.get(), key));
+      changes_.value()->onRemove(key);
     }
-    return res;
+    return outcome::success();
   }
 
 }  // namespace kagome::storage::trie
diff --git a/core/storage/trie/impl/persistent_trie_batch_impl.hpp b/core/storage/trie/impl/persistent_trie_batch_impl.hpp
index 36f9bc8091..e09170764e 100644
--- a/core/storage/trie/impl/persistent_trie_batch_impl.hpp
+++ b/core/storage/trie/impl/persistent_trie_batch_impl.hpp
@@ -54,9 +54,6 @@ namespace kagome::storage::trie {
         std::optional<std::shared_ptr<changes_trie::ChangesTracker>> changes,
         std::shared_ptr<PolkadotTrie> trie);
 
-    // retrieves the current extrinsic index from the storage
-    outcome::result<common::BufferConstRef> getExtrinsicIndex() const;
-
     std::shared_ptr<Codec> codec_;
     std::shared_ptr<TrieSerializer> serializer_;
     std::optional<std::shared_ptr<changes_trie::ChangesTracker>> changes_;
diff --git a/test/core/authorship/proposer_test.cpp b/test/core/authorship/proposer_test.cpp
index 66091cc814..1da81f05bc 100644
--- a/test/core/authorship/proposer_test.cpp
+++ b/test/core/authorship/proposer_test.cpp
@@ -51,9 +51,6 @@ namespace kagome::primitives {
                            const detail::DigestItemCommon &dic) {
     return s;
   }
-  std::ostream &operator<<(std::ostream &s, const ChangesTrieSignal &) {
-    return s;
-  }
 }  // namespace kagome::primitives
 
 class ProposerTest : public ::testing::Test {
diff --git a/test/core/consensus/authority/authority_manager_test.cpp b/test/core/consensus/authority/authority_manager_test.cpp
index 3452f344b7..529d2d8c4f 100644
--- a/test/core/consensus/authority/authority_manager_test.cpp
+++ b/test/core/consensus/authority/authority_manager_test.cpp
@@ -37,9 +37,6 @@ namespace kagome::primitives {
                            const detail::DigestItemCommon &dic) {
     return s;
   }
-  std::ostream &operator<<(std::ostream &s, const ChangesTrieSignal &) {
-    return s;
-  }
 }  // namespace kagome::primitives
 
 class AuthorityManagerTest : public testing::Test {
diff --git a/test/core/consensus/babe/babe_test.cpp b/test/core/consensus/babe/babe_test.cpp
index c6eda22ff7..d94179d519 100644
--- a/test/core/consensus/babe/babe_test.cpp
+++ b/test/core/consensus/babe/babe_test.cpp
@@ -61,9 +61,6 @@ namespace kagome::primitives {
                            const detail::DigestItemCommon &dic) {
     return s;
   }
-  std::ostream &operator<<(std::ostream &s, const ChangesTrieSignal &) {
-    return s;
-  }
 }  // namespace kagome::primitives
 
 static Digest make_digest(BabeSlotNumber slot) {
diff --git a/test/core/host_api/offchain_extension_test.cpp b/test/core/host_api/offchain_extension_test.cpp
index 4addd641c0..59f4443c27 100644
--- a/test/core/host_api/offchain_extension_test.cpp
+++ b/test/core/host_api/offchain_extension_test.cpp
@@ -19,7 +19,6 @@
 #include "offchain/types.hpp"
 #include "runtime/ptr_size.hpp"
 #include "scale/encode_append.hpp"
-#include "storage/changes_trie/changes_trie_config.hpp"
 #include "testutil/literals.hpp"
 #include "testutil/outcome.hpp"
 #include "testutil/outcome/dummy_error.hpp"
diff --git a/test/core/host_api/storage_extension_test.cpp b/test/core/host_api/storage_extension_test.cpp
index d88be45222..e51b2ba683 100644
--- a/test/core/host_api/storage_extension_test.cpp
+++ b/test/core/host_api/storage_extension_test.cpp
@@ -14,12 +14,10 @@
 #include "mock/core/runtime/memory_mock.hpp"
 #include "mock/core/runtime/memory_provider_mock.hpp"
 #include "mock/core/runtime/trie_storage_provider_mock.hpp"
-#include "mock/core/storage/changes_trie/changes_tracker_mock.hpp"
 #include "mock/core/storage/trie/polkadot_trie_cursor_mock.h"
 #include "mock/core/storage/trie/trie_batches_mock.hpp"
 #include "runtime/ptr_size.hpp"
 #include "scale/encode_append.hpp"
-#include "storage/changes_trie/changes_trie_config.hpp"
 #include "storage/predefined_keys.hpp"
 #include "testutil/literals.hpp"
 #include "testutil/outcome.hpp"
@@ -39,7 +37,6 @@ using kagome::runtime::WasmOffset;
 using kagome::runtime::WasmPointer;
 using kagome::runtime::WasmSize;
 using kagome::runtime::WasmSpan;
-using kagome::storage::changes_trie::ChangesTrackerMock;
 using kagome::storage::trie::EphemeralTrieBatchMock;
 using kagome::storage::trie::PersistentTrieBatchMock;
 using kagome::storage::trie::PolkadotCodec;
@@ -72,9 +69,8 @@ class StorageExtensionTest : public ::testing::Test {
     EXPECT_CALL(*memory_provider_, getCurrentMemory())
         .WillRepeatedly(
             Return(std::optional<std::reference_wrapper<Memory>>(*memory_)));
-    changes_tracker_ = std::make_shared<ChangesTrackerMock>();
-    storage_extension_ = std::make_shared<StorageExtension>(
-        storage_provider_, memory_provider_, changes_tracker_);
+    storage_extension_ =
+        std::make_shared<StorageExtension>(storage_provider_, memory_provider_);
   }
 
  protected:
@@ -83,7 +79,6 @@ class StorageExtensionTest : public ::testing::Test {
   std::shared_ptr<MemoryMock> memory_;
   std::shared_ptr<MemoryProviderMock> memory_provider_;
   std::shared_ptr<StorageExtension> storage_extension_;
-  std::shared_ptr<ChangesTrackerMock> changes_tracker_;
   PolkadotCodec codec_;
 
   constexpr static uint32_t kU32Max = std::numeric_limits<uint32_t>::max();
@@ -704,72 +699,3 @@ TEST_F(StorageExtensionTest, Blake2_256_TrieRootV1) {
   ASSERT_EQ(result,
             storage_extension_->ext_trie_blake2_256_root_version_1(dict_data));
 }
-
-/**
- * @given no :changes_trie key (which sets the changes trie config) in storage
- * @when calling ext_storage_changes_root_version_1
- * @then none is returned, changes trie is empty
- */
-TEST_F(StorageExtensionTest, ChangesRootEmpty) {
-  auto parent_hash = "123456"_hash256;
-  Buffer parent_hash_buf{gsl::span(parent_hash.data(), parent_hash.size())};
-  PtrSize parent_root_ptr{1, Hash256::size()};
-  EXPECT_CALL(*memory_, loadN(parent_root_ptr.ptr, Hash256::size()))
-      .WillOnce(Return(parent_hash_buf));
-
-  auto changes_trie_buf = kagome::common::Buffer{}.put(":changes_trie");
-  EXPECT_CALL(*trie_batch_, tryGet(changes_trie_buf.view()))
-      .WillOnce(Return(std::nullopt));
-
-  WasmPointer result = 1984;
-  Buffer none_bytes{0};
-  EXPECT_CALL(*memory_, storeBuffer(gsl::span<const uint8_t>(none_bytes)))
-      .WillOnce(Return(result));
-
-  auto res = storage_extension_->ext_storage_changes_root_version_1(
-      parent_root_ptr.combine());
-  ASSERT_EQ(res, result);
-}
-
-MATCHER_P(configsAreEqual, n, "") {
-  return (arg.digest_interval == n.digest_interval)
-         and (arg.digest_levels == n.digest_levels);
-}
-
-/**
- * @given existing :changes_trie key (which sets the changes trie config) in
- * storage and there are accumulated changes
- * @when calling ext_storage_changes_root_version_1
- * @then a valid trie root is returned
- */
-TEST_F(StorageExtensionTest, ChangesRootNotEmpty) {
-  auto parent_hash = "123456"_hash256;
-  Buffer parent_hash_buf{gsl::span(parent_hash.data(), parent_hash.size())};
-  PtrSize parent_root_ptr{1, Hash256::size()};
-  EXPECT_CALL(*memory_, loadN(parent_root_ptr.ptr, Hash256::size()))
-      .WillOnce(Return(parent_hash_buf));
-
-  kagome::storage::changes_trie::ChangesTrieConfig config{.digest_interval = 0,
-                                                          .digest_levels = 0};
-  auto changes_trie_buf = kagome::common::Buffer{}.put(":changes_trie");
-  EXPECT_CALL(*trie_batch_, tryGet(changes_trie_buf.view()))
-      .WillOnce(Return(Buffer(scale::encode(config).value())));
-
-  auto trie_hash = "deadbeef"_hash256;
-  auto enc_trie_hash =
-      scale::encode(
-          std::make_optional((gsl::span(trie_hash.data(), Hash256::size()))))
-          .value();
-  EXPECT_CALL(*changes_tracker_,
-              constructChangesTrie(parent_hash, configsAreEqual(config)))
-      .WillOnce(Return(trie_hash));
-
-  WasmPointer result = 1984;
-  Buffer none_bytes{0};
-  EXPECT_CALL(*memory_, storeBuffer(gsl::span<const uint8_t>(enc_trie_hash)))
-      .WillOnce(Return(result));
-
-  auto res = storage_extension_->ext_storage_changes_root_version_1(
-      parent_root_ptr.combine());
-  ASSERT_EQ(res, result);
-}
diff --git a/test/core/runtime/runtime_test_base.hpp b/test/core/runtime/runtime_test_base.hpp
index a92f298466..7fc6152fc5 100644
--- a/test/core/runtime/runtime_test_base.hpp
+++ b/test/core/runtime/runtime_test_base.hpp
@@ -99,7 +99,6 @@ class RuntimeTestBase : public ::testing::Test {
 
     host_api_factory_ = std::make_shared<host_api::HostApiFactoryImpl>(
         kagome::host_api::OffchainExtensionConfig{},
-        changes_tracker_,
         sr25519_provider,
         ecdsa_provider,
         ed25519_provider,
diff --git a/test/core/runtime/wavm/core_integration_test.cpp b/test/core/runtime/wavm/core_integration_test.cpp
index 021cccbf23..df4daa2623 100644
--- a/test/core/runtime/wavm/core_integration_test.cpp
+++ b/test/core/runtime/wavm/core_integration_test.cpp
@@ -66,10 +66,9 @@ TEST_F(CoreTest, DISABLED_VersionTest) {
  */
 TEST_F(CoreTest, DISABLED_ExecuteBlockTest) {
   auto block = createBlock("block_hash"_hash256, 42);
-  EXPECT_CALL(
-      *changes_tracker_,
-      onBlockExecutionStart(block.header.parent_hash, block.header.number - 1))
-      .WillOnce(Return(outcome::success()));
+  EXPECT_CALL(*changes_tracker_,
+              onBlockExecutionStart(block.header.parent_hash))
+      .WillOnce(Return());
 
   ASSERT_TRUE(core_->execute_block(block));
 }
@@ -81,9 +80,8 @@ TEST_F(CoreTest, DISABLED_ExecuteBlockTest) {
  */
 TEST_F(CoreTest, DISABLED_InitializeBlockTest) {
   auto header = createBlockHeader("block_hash"_hash256, 42);
-  EXPECT_CALL(*changes_tracker_,
-              onBlockExecutionStart(header.parent_hash, header.number - 1))
-      .WillOnce(Return(outcome::success()));
+  EXPECT_CALL(*changes_tracker_, onBlockExecutionStart(header.parent_hash))
+      .WillOnce(Return());
 
   ASSERT_TRUE(core_->initialize_block(header));
 }
diff --git a/test/core/runtime/wavm/wasm_executor_test.cpp b/test/core/runtime/wavm/wasm_executor_test.cpp
index 49f3649930..482aa7bb3b 100644
--- a/test/core/runtime/wavm/wasm_executor_test.cpp
+++ b/test/core/runtime/wavm/wasm_executor_test.cpp
@@ -143,7 +143,6 @@ class WasmExecutorTest : public ::testing::Test {
     auto host_api_factory =
         std::make_shared<kagome::host_api::HostApiFactoryImpl>(
             kagome::host_api::OffchainExtensionConfig{},
-            std::make_shared<ChangesTrackerMock>(),
             sr25519_provider,
             ecdsa_provider,
             ed25519_provider,
diff --git a/test/core/storage/changes_trie/changes_tracker_test.cpp b/test/core/storage/changes_trie/changes_tracker_test.cpp
index fe7ffd719c..18db45989c 100644
--- a/test/core/storage/changes_trie/changes_tracker_test.cpp
+++ b/test/core/storage/changes_trie/changes_tracker_test.cpp
@@ -59,12 +59,9 @@ TEST(ChangesTrieTest, IntegrationWithOverlay) {
       std::make_shared<StorageSubscriptionEngine>();
   auto chain_subscription_engine = std::make_shared<ChainSubscriptionEngine>();
   std::shared_ptr<ChangesTracker> changes_tracker =
-      std::make_shared<StorageChangesTrackerImpl>(factory,
-                                                  codec,
-                                                  storage_subscription_engine,
+      std::make_shared<StorageChangesTrackerImpl>(storage_subscription_engine,
                                                   chain_subscription_engine);
-  EXPECT_OUTCOME_TRUE_1(
-      changes_tracker->onBlockExecutionStart("aaa"_hash256, 42));
+  changes_tracker->onBlockExecutionStart("aaa"_hash256);
   auto batch = PersistentTrieBatchImpl::create(
       codec,
       serializer,
@@ -79,7 +76,5 @@ TEST(ChangesTrieTest, IntegrationWithOverlay) {
   auto repo = std::make_shared<BlockHeaderRepositoryMock>();
   EXPECT_CALL(*repo, getNumberByHash(_)).WillRepeatedly(Return(42));
 
-  EXPECT_OUTCOME_TRUE_1(
-      changes_tracker->constructChangesTrie("aaa"_hash256, {}));
   // THEN SUCCESS
 }
diff --git a/test/external-project-test/src/main.cpp b/test/external-project-test/src/main.cpp
index ebd2b5ca9b..255a052016 100644
--- a/test/external-project-test/src/main.cpp
+++ b/test/external-project-test/src/main.cpp
@@ -75,7 +75,7 @@ int main() {
 
   leveldb::Options db_options{};
   db_options.create_if_missing = true;
-  std::shared_ptr database =
+  std::shared_ptr<kagome::storage::LevelDB> database =
       kagome::storage::LevelDB::create("/tmp/kagome_tmp_db", db_options)
           .value();
   auto hasher = std::make_shared<kagome::crypto::HasherImpl>();
@@ -108,15 +108,12 @@ int main() {
 
   auto changes_tracker = std::make_shared<
       kagome::storage::changes_trie::StorageChangesTrackerImpl>(
-      trie_factory,
-      codec,
-      storage_subscription_engine,
-      chain_subscription_engine);
+      storage_subscription_engine, chain_subscription_engine);
 
-  auto trie_storage =
-      std::shared_ptr(kagome::storage::trie::TrieStorageImpl::createEmpty(
-                          trie_factory, codec, serializer, changes_tracker)
-                          .value());
+  std::shared_ptr<kagome::storage::trie::TrieStorageImpl> trie_storage =
+      kagome::storage::trie::TrieStorageImpl::createEmpty(
+          trie_factory, codec, serializer, changes_tracker)
+          .value();
 
   auto batch =
       trie_storage->getPersistentBatchAt(serializer->getEmptyRootHash())
@@ -169,9 +166,9 @@ int main() {
       std::make_shared<kagome::crypto::Ed25519Suite>(ed25519_provider);
   auto sr_suite =
       std::make_shared<kagome::crypto::Sr25519Suite>(sr25519_provider);
-  auto key_fs = std::shared_ptr(
+  std::shared_ptr<kagome::crypto::KeyFileStorage> key_fs =
       kagome::crypto::KeyFileStorage::createAt("/tmp/kagome_tmp_key_storage")
-          .value());
+          .value();
   auto crypto_store = std::make_shared<kagome::crypto::CryptoStoreImpl>(
       ecdsa_suite, ed_suite, sr_suite, bip39_provider, key_fs);
 
@@ -185,7 +182,6 @@ int main() {
   auto host_api_factory =
       std::make_shared<kagome::host_api::HostApiFactoryImpl>(
           kagome::host_api::OffchainExtensionConfig{},
-          changes_tracker,
           sr25519_provider,
           ecdsa_provider,
           ed25519_provider,
diff --git a/test/mock/core/storage/changes_trie/changes_tracker_mock.hpp b/test/mock/core/storage/changes_trie/changes_tracker_mock.hpp
index eb9c8e691d..df656ee505 100644
--- a/test/mock/core/storage/changes_trie/changes_tracker_mock.hpp
+++ b/test/mock/core/storage/changes_trie/changes_tracker_mock.hpp
@@ -14,14 +14,9 @@ namespace kagome::storage::changes_trie {
 
   class ChangesTrackerMock : public ChangesTracker {
    public:
-    MOCK_METHOD(void, setBlockHash, (const primitives::BlockHash &hash), ());
-
-    MOCK_METHOD(void, setConfig, (const ChangesTrieConfig &conf), ());
-
-    MOCK_METHOD(outcome::result<void>,
+    MOCK_METHOD(void,
                 onBlockExecutionStart,
-                (primitives::BlockHash new_parent_hash,
-                 primitives::BlockNumber new_parent_number),
+                (primitives::BlockHash new_parent_hash),
                 (override));
 
     MOCK_METHOD(void,
@@ -29,26 +24,14 @@ namespace kagome::storage::changes_trie {
                 (const primitives::BlockHash &block_hash),
                 (override));
 
-    MOCK_METHOD(void, onClearPrefix, (const common::BufferView &), (override));
-
-    MOCK_METHOD(outcome::result<void>,
+    MOCK_METHOD(void,
                 onPut,
-                (common::BufferView ext_idx,
-                 const common::BufferView &key,
+                (const common::BufferView &key,
                  const common::BufferView &value,
                  bool is_new_entry),
                 (override));
 
-    MOCK_METHOD(outcome::result<void>,
-                onRemove,
-                (common::BufferView ext_idx, const common::BufferView &key),
-                (override));
-
-    MOCK_METHOD(outcome::result<common::Hash256>,
-                constructChangesTrie,
-                (const primitives::BlockHash &parent,
-                 const ChangesTrieConfig &conf),
-                (override));
+    MOCK_METHOD(void, onRemove, (const common::BufferView &key), (override));
   };
 
 }  // namespace kagome::storage::changes_trie