#include "crimson/os/seastore/segment_manager_group.h"
 #include "crimson/os/seastore/randomblock_manager_group.h"
 #include "crimson/os/seastore/transaction.h"
+#include "crimson/os/seastore/transaction_interruptor.h"
 #include "crimson/os/seastore/segment_seq_allocator.h"
 #include "crimson/os/seastore/backref_mapping.h"
 
  */
 class ExtentCallbackInterface {
 public:
-  using base_ertr = crimson::errorator<
-    crimson::ct_error::input_output_error>;
-  using base_iertr = trans_iertr<base_ertr>;
-
   virtual ~ExtentCallbackInterface() = default;
 
   virtual shard_stats_t& get_shard_stats() = 0;
 
 
 class ObjectDataHandler {
 public:
-  using base_iertr = TransactionManager::base_iertr;
-
   ObjectDataHandler(uint32_t mos) : max_object_size(mos),
     delta_based_overwrite_max_extent_size(
       crimson::common::get_conf<Option::size_t>("seastore_data_delta_based_overwrite")) {}
 
   * until these functions future resolved.
   */
 public:
-  using base_iertr = TransactionManager::base_iertr;
-
   /**
    * allocate omap tree root node
    *
 
 };
 
 struct OMapNode : LogicalChildNode {
-  using base_iertr = OMapManager::base_iertr;
-
   using OMapNodeRef = TCachedExtentRef<OMapNode>;
 
   struct mutation_result_t {
 
   return out;
 }
 
-using dec_ref_iertr = OMapInnerNode::base_iertr;
+using dec_ref_iertr = base_iertr;
 using dec_ref_ret = dec_ref_iertr::future<>;
 template <typename T>
 dec_ref_ret dec_ref(omap_context_t oc, T&& addr) {
 
     OMapNodeRef l,
     OMapNodeRef r);
 
-  using get_child_node_iertr = OMapNode::base_iertr;
+  using get_child_node_iertr = base_iertr;
   using get_child_node_ret = get_child_node_iertr::future<OMapNodeRef>;
   get_child_node_ret get_child_node(
     omap_context_t oc,
 };
 using OMapLeafNodeRef = OMapLeafNode::OMapLeafNodeRef;
 
-using omap_load_extent_iertr = OMapNode::base_iertr;
+using omap_load_extent_iertr = base_iertr;
 template <typename T>
 requires std::is_same_v<OMapInnerNode, T> || std::is_same_v<OMapLeafNode, T>
 omap_load_extent_iertr::future<TCachedExtentRef<T>>
 
 namespace crimson::os::seastore {
 
 class OnodeManager {
-  using base_iertr = TransactionManager::base_iertr;
 public:
   using mkfs_iertr = base_iertr;
   using mkfs_ret = mkfs_iertr::future<>;
 
 
 using crimson::os::seastore::TransactionManager;
 class NodeExtentManager {
-  using base_iertr = TransactionManager::base_iertr;
  public:
   virtual ~NodeExtentManager() = default;
 
 
   });
 }
 
-SeaStore::base_iertr::future<ceph::bufferlist>
+base_iertr::future<ceph::bufferlist>
 SeaStore::Shard::_read(
   Transaction& t,
   Onode& onode,
   });
 }
 
-SeaStore::base_iertr::future<SeaStore::Shard::attrs_t>
+base_iertr::future<SeaStore::Shard::attrs_t>
 SeaStore::Shard::_get_attrs(
   Transaction& t,
   Onode& onode)
   });
 }
 
-SeaStore::base_iertr::future<SeaStore::Shard::fiemap_ret_t>
+base_iertr::future<SeaStore::Shard::fiemap_ret_t>
 SeaStore::Shard::_fiemap(
   Transaction &t,
   Onode &onode,
   });
 }
 
-SeaStore::base_iertr::future<SeaStore::Shard::omap_values_t>
+base_iertr::future<SeaStore::Shard::omap_values_t>
 SeaStore::Shard::omaptree_get_values(
   Transaction& t,
   omap_root_t&& root,
   });
 }
 
-SeaStore::base_iertr::future<SeaStore::Shard::omap_values_paged_t>
+base_iertr::future<SeaStore::Shard::omap_values_paged_t>
 SeaStore::Shard::omaptree_get_values(
   Transaction& t,
   omap_root_t&& root,
   });
 }
 
-SeaStore::base_iertr::future<omap_root_t>
+base_iertr::future<omap_root_t>
 SeaStore::Shard::omaptree_do_clear(
   Transaction& t,
   omap_root_t&& root)
   });
 }
 
-SeaStore::base_iertr::future<>
+base_iertr::future<>
 SeaStore::Shard::omaptree_clear_no_onode(
   Transaction& t,
   omap_root_t&& root)
   }
 }
 
-SeaStore::base_iertr::future<>
+base_iertr::future<>
 SeaStore::Shard::omaptree_clear(
   Transaction& t,
   omap_root_t&& root,
   });
 }
 
-SeaStore::base_iertr::future<>
+base_iertr::future<>
 SeaStore::Shard::omaptree_clone(
   Transaction& t,
   omap_type_t type,
   });
 }
 
-SeaStore::base_iertr::future<>
+base_iertr::future<>
 SeaStore::Shard::omaptree_rm_keys(
   Transaction& t,
   omap_root_t&& root,
   });
 }
 
-SeaStore::base_iertr::future<>
+base_iertr::future<>
 SeaStore::Shard::omaptree_rm_keyrange(
   Transaction& t,
   omap_root_t&& root,
   });
 }
 
-SeaStore::base_iertr::future<>
+base_iertr::future<>
 SeaStore::Shard::omaptree_rm_key(
   Transaction& t,
   omap_root_t&& root,
 
 
 class SeaStore final : public FuturizedStore {
 public:
-  using base_ertr = TransactionManager::base_ertr;
-  using base_iertr = TransactionManager::base_iertr;
-
   class MDStore {
   public:
     using write_meta_ertr = base_ertr;
 
         trans, std::move(opin), std::array{
           remap_entry_t(new_offset, new_len)}
       ).si_then([](auto ret) {
-        return TransactionManager::base_iertr::make_ready_future<
+        return base_iertr::make_ready_future<
          std::optional<LBAMapping>>(std::move(ret[0]));
       });
     }).handle_error(crimson::ct_error::eagain::handle([] {
-      return TransactionManager::base_iertr::make_ready_future<
+      return base_iertr::make_ready_future<
        std::optional<LBAMapping>>();
     }), crimson::ct_error::pass_further_all{}).unsafe_get();
     EXPECT_TRUE(pin);
 
   TestBlockRef try_read_pin(
     test_transaction_t &t,
     const LBAMapping pin) {
-    using ertr = with_trans_ertr<TransactionManager::base_iertr>;
+    using ertr = with_trans_ertr<base_iertr>;
     bool indirect = pin.is_indirect();
     auto addr = pin.get_key();
     auto im_addr = pin.get_intermediate_base();
         trans, std::move(opin), std::array{
           remap_entry_t(new_offset, new_len)}
       ).si_then([](auto ret) {
-        return TransactionManager::base_iertr::make_ready_future<
+        return base_iertr::make_ready_future<
          std::optional<LBAMapping>>(std::move(ret[0]));
       });
     }).handle_error(crimson::ct_error::eagain::handle([] {
-      return TransactionManager::base_iertr::make_ready_future<
+      return base_iertr::make_ready_future<
        std::optional<LBAMapping>>();
     }), crimson::ct_error::pass_further_all{}).unsafe_get();
     if (t.t->is_conflicted()) {
 
       });
   }
   auto submit_transaction_fut_with_seq(Transaction &t) {
-    using ertr = TransactionManager::base_iertr;
     return with_trans_intr(
       t,
       [this](auto &t) {
        return tm->submit_transaction(t
        ).si_then([this] {
-         return ertr::make_ready_future<uint64_t>(seq++);
+         return base_iertr::make_ready_future<uint64_t>(seq++);
        });
       });
   }