light events for actor system

513 files changed, 3324 insertions, 2107 deletions

diff --git a/library/cpp/actors/core/actor.cpp b/library/cpp/actors/core/actor.cpp
index 00eef387ea4..304f7405aea 100644
--- a/library/cpp/actors/core/actor.cpp
+++ b/library/cpp/actors/core/actor.cpp
@@ -16,6 +16,22 @@ namespace NActors {
         return SelfActorId.Send(recipient, ev, flags, cookie, std::move(traceId));
     }
 
+    bool IActor::Send(const TActorId& recipient, IEventHandleLight* ev) const noexcept {
+        return SelfActorId.Send(recipient, ev);
+    }
+
+    bool IActor::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags) const noexcept {
+        return SelfActorId.Send(recipient, ev, flags);
+    }
+
+    bool IActor::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie) const noexcept {
+        return SelfActorId.Send(recipient, ev, flags, cookie);
+    }
+
+    bool IActor::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const noexcept {
+        return SelfActorId.Send(recipient, ev, flags, cookie, std::move(traceId));
+    }
+
     void TActivationContext::Schedule(TInstant deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) {
         TlsActivationContext->ExecutorThread.Schedule(deadline, ev, cookie);
     }
@@ -29,15 +45,15 @@ namespace NActors {
     }
 
     void TActorIdentity::Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie) const {
-        return TActivationContext::Schedule(deadline, new IEventHandle(*this, {}, ev), cookie);
+        return TActivationContext::Schedule(deadline, new IEventHandleFat(*this, {}, ev), cookie);
     }
 
     void TActorIdentity::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const {
-        return TActivationContext::Schedule(deadline, new IEventHandle(*this, {}, ev), cookie);
+        return TActivationContext::Schedule(deadline, new IEventHandleFat(*this, {}, ev), cookie);
     }
 
     void TActorIdentity::Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie) const {
-        return TActivationContext::Schedule(delta, new IEventHandle(*this, {}, ev), cookie);
+        return TActivationContext::Schedule(delta, new IEventHandleFat(*this, {}, ev), cookie);
     }
 
     TActorId TActivationContext::RegisterWithSameMailbox(IActor* actor, TActorId parentId) {
@@ -75,27 +91,27 @@ namespace NActors {
     }
 
     void TActorContext::Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie) const {
-        ExecutorThread.Schedule(deadline, new IEventHandle(SelfID, TActorId(), ev), cookie);
+        ExecutorThread.Schedule(deadline, new IEventHandleFat(SelfID, TActorId(), ev), cookie);
     }
 
     void TActorContext::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const {
-        ExecutorThread.Schedule(deadline, new IEventHandle(SelfID, TActorId(), ev), cookie);
+        ExecutorThread.Schedule(deadline, new IEventHandleFat(SelfID, TActorId(), ev), cookie);
     }
 
     void TActorContext::Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie) const {
-        ExecutorThread.Schedule(delta, new IEventHandle(SelfID, TActorId(), ev), cookie);
+        ExecutorThread.Schedule(delta, new IEventHandleFat(SelfID, TActorId(), ev), cookie);
     }
 
     void IActor::Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie) const noexcept {
-        TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandle(SelfActorId, TActorId(), ev), cookie);
+        TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandleFat(SelfActorId, TActorId(), ev), cookie);
     }
 
     void IActor::Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie) const noexcept {
-        TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandle(SelfActorId, TActorId(), ev), cookie);
+        TlsActivationContext->ExecutorThread.Schedule(deadline, new IEventHandleFat(SelfActorId, TActorId(), ev), cookie);
     }
 
     void IActor::Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie) const noexcept {
-        TlsActivationContext->ExecutorThread.Schedule(delta, new IEventHandle(SelfActorId, TActorId(), ev), cookie);
+        TlsActivationContext->ExecutorThread.Schedule(delta, new IEventHandleFat(SelfActorId, TActorId(), ev), cookie);
     }
 
     TInstant TActivationContext::Now() {
@@ -145,7 +161,7 @@ namespace NActors {
         (actor->*StateFunc)(ev, TActivationContext::AsActorContext());
     }
 
-    void TActorVirtualBehaviour::Receive(IActor* actor, std::unique_ptr<IEventHandle> ev) {
+    void TActorVirtualBehaviour::Receive(IActor* actor, std::unique_ptr<IEventHandleFat> ev) {
         Y_VERIFY(!!ev && ev->GetBase());
         ev->GetBase()->Execute(actor, std::move(ev));
     }
diff --git a/library/cpp/actors/core/actor.h b/library/cpp/actors/core/actor.h
index 0e109da8192..08a3beb2bfc 100644
--- a/library/cpp/actors/core/actor.h
+++ b/library/cpp/actors/core/actor.h
@@ -59,6 +59,12 @@ namespace NActors {
         template <ESendingType SendingType = ESendingType::Common>
         static bool Send(std::unique_ptr<IEventHandle> &&ev);
 
+        template <ESendingType SendingType = ESendingType::Common>
+        static bool Forward(TAutoPtr<IEventHandle>& ev, const TActorId& recipient);
+
+        template <ESendingType SendingType = ESendingType::Common>
+        static bool Forward(THolder<IEventHandle>& ev, const TActorId& recipient);
+
         /**
          * Schedule one-shot event that will be send at given time point in the future.
          *
@@ -132,10 +138,16 @@ namespace NActors {
         template <ESendingType SendingType = ESendingType::Common>
         bool Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const;
         template <ESendingType SendingType = ESendingType::Common>
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const;
+        template <ESendingType SendingType = ESendingType::Common>
         bool Send(const TActorId& recipient, THolder<IEventBase> ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const {
             return Send<SendingType>(recipient, ev.Release(), flags, cookie, std::move(traceId));
         }
         template <ESendingType SendingType = ESendingType::Common>
+        bool Send(const TActorId& recipient, THolder<IEventHandleLight> ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const {
+            return Send<SendingType>(recipient, ev.Release(), flags, cookie, std::move(traceId));
+        }
+        template <ESendingType SendingType = ESendingType::Common>
         bool Send(const TActorId& recipient, std::unique_ptr<IEventBase> ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const {
             return Send<SendingType>(recipient, ev.release(), flags, cookie, std::move(traceId));
         }
@@ -145,6 +157,15 @@ namespace NActors {
         bool Send(std::unique_ptr<IEventHandle> &&ev) const {
             return Send<SendingType>(TAutoPtr<IEventHandle>(ev.release()));
         }
+        template <ESendingType SendingType = ESendingType::Common>
+        bool Forward(TAutoPtr<IEventHandle>& ev, const TActorId& recipient) const;
+        template <ESendingType SendingType = ESendingType::Common>
+        bool Forward(THolder<IEventHandle>& ev, const TActorId& recipient) const;
+        template <ESendingType SendingType = ESendingType::Common, typename TEventHandle>
+        bool Forward(TAutoPtr<TEventHandle>& ev, const TActorId& recipient) const {
+            TAutoPtr<IEventHandle> evi(ev.Release());
+            return Forward(evi, recipient);
+        }
 
         TInstant Now() const;
         TMonotonic Monotonic() const;
@@ -206,6 +227,15 @@ namespace NActors {
 
         template <ESendingType SendingType = ESendingType::Common>
         bool Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const;
+        template <ESendingType SendingType = ESendingType::Common>
+        bool Send(const TActorId& recipient, IEventHandleLight* ev) const;
+        template <ESendingType SendingType = ESendingType::Common>
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags) const;
+        template <ESendingType SendingType = ESendingType::Common>
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie) const;
+        template <ESendingType SendingType = ESendingType::Common>
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const;
+        bool SendWithContinuousExecution(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const;
         void Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const;
         void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const;
         void Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const;
@@ -253,7 +283,7 @@ namespace NActors {
 
     class TActorVirtualBehaviour {
     public:
-        static void Receive(IActor* actor, std::unique_ptr<IEventHandle> ev);
+        static void Receive(IActor* actor, std::unique_ptr<IEventHandleFat> ev);
     public:
     };
 
@@ -262,8 +292,7 @@ namespace NActors {
         using TBase = IActor;
         friend class TDecorator;
     public:
-        typedef void (IActor::* TReceiveFunc)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
-
+        using TReceiveFunc = void (IActor::*)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx);
     private:
         TReceiveFunc StateFunc = nullptr;
     public:
@@ -303,6 +332,8 @@ namespace NActors {
         friend void DoActorInit(TActorSystem*, IActor*, const TActorId&, const TActorId&);
         friend class TDecorator;
     protected:
+        using TReceiveFuncLight = void (IActor::*)(TAutoPtr<IEventHandle>& ev);
+        TReceiveFuncLight StateFuncLight = nullptr;
         TActorCallbackBehaviour CImpl;
     public:
         using TReceiveFunc = TActorCallbackBehaviour::TReceiveFunc;
@@ -476,19 +507,28 @@ namespace NActors {
         TActorIdentity SelfId() const {
             return SelfActorId;
         }
-        void Receive(TAutoPtr<IEventHandle>& ev, const TActorContext& /*ctx*/) {
+        // void Receive(TAutoPtr<IEventHandle> ev, const TActorContext& /*ctx*/) {
+        //     Receive(ev);
+        // }
+        void Receive(TAutoPtr<IEventHandle>& ev) {
             ++HandledEvents;
-            if (CImpl.Initialized()) {
+            if (StateFuncLight) {
+                (this->*StateFuncLight)(ev);
+            } else if (CImpl.Initialized()) {
                 CImpl.Receive(this, ev);
             } else {
-                TActorVirtualBehaviour::Receive(this, std::unique_ptr<IEventHandle>(ev.Release()));
+                TActorVirtualBehaviour::Receive(this, std::unique_ptr<IEventHandleFat>(IEventHandleFat::MakeFat(ev).Release()));
             }
         }
 
     protected:
         void Describe(IOutputStream&) const noexcept override;
         bool Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const noexcept final;
-        bool Send(const TActorId& recipient, THolder<IEventBase> ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const {
+        bool Send(const TActorId& recipient, IEventHandleLight* ev) const noexcept;
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags) const noexcept;
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie) const noexcept;
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const noexcept;
+        bool Send(const TActorId& recipient, THolder<IEventBase> ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const{
             return Send(recipient, ev.Release(), flags, cookie, std::move(traceId));
         }
         bool Send(const TActorId& recipient, std::unique_ptr<IEventBase> ev, ui32 flags = 0, ui64 cookie = 0, NWilson::TTraceId traceId = {}) const {
@@ -511,6 +551,20 @@ namespace NActors {
             return Send(recipient, ev.release(), flags, cookie, std::move(traceId));
         }
 
+        bool Forward(TAutoPtr<IEventHandle>& ev, const TActorId& recipient) {
+            return TActivationContext::Forward(ev, recipient);
+        }
+
+        bool Forward(THolder<IEventHandle>& ev, const TActorId& recipient) {
+            return TActivationContext::Forward(ev, recipient);
+        }
+
+        template <typename TEventHandle>
+        bool Forward(TAutoPtr<TEventHandle>& ev, const TActorId& recipient) const {
+            TAutoPtr<IEventHandle> evi(ev.Release());
+            return Forward(evi, recipient);
+        }
+
         void Schedule(TInstant deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final;
         void Schedule(TMonotonic deadline, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final;
         void Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie = nullptr) const noexcept final;
@@ -574,8 +628,78 @@ namespace NActors {
         }
     };
 
+    template<typename TDerived>
+    class TActorCallback : public IActorCallback {
+    public:
+        using TFatReceiveFunc = void (TDerived::*)(TAutoPtr<IEventHandle>&, const TActorContext&);
+        using TLightReceiveFunc = void (TDerived::*)(TAutoPtr<IEventHandle>&);
+
+    private:
+        void BecomeFat(TFatReceiveFunc stateFunc) {
+            IActorCallback::Become(stateFunc);
+        }
+
+        template<typename... TArgs>
+        void BecomeFat(TFatReceiveFunc stateFunc, const TActorContext& ctx, TArgs&&... args) {
+            IActorCallback::Become(stateFunc, ctx, std::forward<TArgs>(args)...);
+        }
+
+        template<typename... TArgs>
+        void BecomeFat(TFatReceiveFunc stateFunc, TArgs&&... args) {
+            IActorCallback::Become(stateFunc, std::forward<TArgs>(args)...);
+        }
+
+        void BecomeLight(TLightReceiveFunc stateFuncLight) {
+            StateFuncLight = static_cast<TReceiveFuncLight>(stateFuncLight);
+        }
+
+    public:
+        TActorCallback(TFatReceiveFunc stateFunc, ui32 activityType = OTHER)
+            : IActorCallback(static_cast<TReceiveFunc>(stateFunc), activityType)
+        {
+        }
+
+        TActorCallback(TLightReceiveFunc stateFunc, ui32 activityType = OTHER)
+            : IActorCallback(nullptr, activityType)
+        {
+            Become(stateFunc);
+        }
+
+        template<typename T>
+        void Become(T stateFunc) {
+            IActorCallback::Become(stateFunc);
+        }
+
+        template<typename T, typename... TArgs>
+        void Become(T stateFunc, const TActorContext&, TArgs&&... args) {
+            IActorCallback::Become(stateFunc);
+            Schedule(std::forward<TArgs>(args)...);
+        }
+
+        template<typename T, typename... TArgs>
+        void Become(T stateFunc, TArgs&&... args) {
+            IActorCallback::Become(stateFunc);
+            Schedule(std::forward<TArgs>(args)...);
+        }
+
+        template<>
+        void Become<TLightReceiveFunc>(TLightReceiveFunc stateFunc) {
+            BecomeLight(stateFunc);
+        }
+
+        template<>
+        void Become<TFatReceiveFunc>(TFatReceiveFunc stateFunc) {
+            BecomeFat(stateFunc);
+        }
+
+        template<typename... TArgs>
+        void Become(TFatReceiveFunc stateFunc, const TActorContext& ctx, TArgs&&... args) {
+            BecomeFat(stateFunc, ctx, std::forward<TArgs>(args)...);
+        }
+    };
+
     template <typename TDerived>
-    class TActor: public IActorCallback {
+    class TActor: public TActorCallback<TDerived> {
     private:
         template <typename T, typename = const char*>
         struct HasActorName: std::false_type { };
@@ -601,14 +725,20 @@ namespace NActors {
     protected:
         //* Comment this function to find unmarked activities
         static constexpr IActor::EActivityType ActorActivityType() {
-            return EActorActivity::OTHER;
+            return IActorCallback::EActorActivity::OTHER;
         } //*/
 
         // static constexpr char ActorName[] = "UNNAMED";
 
-        TActor(void (TDerived::*func)(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx), ui32 activityType = GetActivityTypeIndex())
-            : IActorCallback(static_cast<TReceiveFunc>(func), activityType)
-        { }
+        TActor(typename TActorCallback<TDerived>::TFatReceiveFunc func, ui32 activityType = GetActivityTypeIndex())
+            : TActorCallback<TDerived>(func, activityType)
+        {
+        }
+
+        TActor(typename TActorCallback<TDerived>::TLightReceiveFunc func, ui32 activityType = GetActivityTypeIndex())
+            : TActorCallback<TDerived>(func, activityType)
+        {
+        }
 
     public:
         typedef TDerived TThis;
@@ -617,8 +747,10 @@ namespace NActors {
 
 #define STFUNC_SIG TAutoPtr< ::NActors::IEventHandle>&ev, const ::NActors::TActorContext &ctx
 #define STATEFN_SIG TAutoPtr<::NActors::IEventHandle>& ev
+#define LIGHTFN_SIG TAutoPtr<::NActors::IEventHandle>& ev
 #define STFUNC(funcName) void funcName(TAutoPtr< ::NActors::IEventHandle>& ev, const ::NActors::TActorContext& ctx)
 #define STATEFN(funcName) void funcName(TAutoPtr< ::NActors::IEventHandle>& ev, const ::NActors::TActorContext& )
+#define LIGHTFN(funcName) void funcName(TAutoPtr<::NActors::IEventHandle>& ev)
 
 #define STFUNC_STRICT_UNHANDLED_MSG_HANDLER Y_VERIFY_DEBUG(false, "%s: unexpected message type 0x%08" PRIx32, __func__, etype);
 
@@ -630,13 +762,26 @@ namespace NActors {
         UNHANDLED_MSG_HANDLER                                           \
     }
 
+#define LIGHTFN_BODY(HANDLERS, UNHANDLED_MSG_HANDLER)                   \
+    switch (const ui32 etype = ev->GetTypeRewrite()) {                  \
+        HANDLERS                                                        \
+    default:                                                            \
+        UNHANDLED_MSG_HANDLER                                           \
+    }
+
 #define STRICT_STFUNC_BODY(HANDLERS) STFUNC_BODY(HANDLERS, STFUNC_STRICT_UNHANDLED_MSG_HANDLER)
+#define STRICT_LIGHTFN_BODY(HANDLERS) LIGHTFN_BODY(HANDLERS, STFUNC_STRICT_UNHANDLED_MSG_HANDLER)
 
 #define STRICT_STFUNC(NAME, HANDLERS)           \
     void NAME(STFUNC_SIG) {                     \
         STRICT_STFUNC_BODY(HANDLERS)            \
     }
 
+#define STRICT_LIGHTFN(NAME, HANDLERS)          \
+    void NAME(LIGHTFN_SIG) {                    \
+        STRICT_LIGHTFN_BODY(HANDLERS)           \
+    }
+
 #define STRICT_STFUNC_EXC(NAME, HANDLERS, EXCEPTION_HANDLERS)           \
     void NAME(STFUNC_SIG) {                                             \
         try {                                                           \
@@ -681,7 +826,7 @@ namespace NActors {
 
         STFUNC(State) {
             if (DoBeforeReceiving(ev, ctx)) {
-                Actor->Receive(ev, ctx);
+                Actor->Receive(ev);
                 DoAfterReceiving(ctx);
             }
         }
@@ -777,8 +922,26 @@ namespace NActors {
     }
 
     template <ESendingType SendingType>
+    bool TActivationContext::Forward(TAutoPtr<IEventHandle>& ev, const TActorId& recipient) {
+        IEventHandle::Forward(ev, recipient);
+        return Send(ev);
+    }
+
+    template <ESendingType SendingType>
+    bool TActivationContext::Forward(THolder<IEventHandle>& ev, const TActorId& recipient) {
+        IEventHandle::Forward(ev, recipient);
+        return Send(ev);
+    }
+
+    template <ESendingType SendingType>
     bool TActorContext::Send(const TActorId& recipient, IEventBase* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const {
-        return Send<SendingType>(new IEventHandle(recipient, SelfID, ev, flags, cookie, nullptr, std::move(traceId)));
+        return Send<SendingType>(new IEventHandleFat(recipient, SelfID, ev, flags, cookie, nullptr, std::move(traceId)));
+    }
+
+    template <ESendingType SendingType>
+    bool TActorContext::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const {
+        ev->PrepareSend(recipient, SelfID, flags, cookie, std::move(traceId));
+        return Send<SendingType>(ev);
     }
 
     template <ESendingType SendingType>
@@ -787,6 +950,18 @@ namespace NActors {
     }
 
     template <ESendingType SendingType>
+    bool TActorContext::Forward(TAutoPtr<IEventHandle>& ev, const TActorId& recipient) const {
+        IEventHandle::Forward(ev, recipient);
+        return ExecutorThread.Send<SendingType>(ev);
+    }
+
+    template <ESendingType SendingType>
+    bool TActorContext::Forward(THolder<IEventHandle>& ev, const TActorId& recipient) const {
+        IEventHandle::Forward(ev, recipient);
+        return ExecutorThread.Send<SendingType>(ev);
+    }
+
+    template <ESendingType SendingType>
     TActorId TActivationContext::Register(IActor* actor, TActorId parentId, TMailboxType::EType mailboxType, ui32 poolId) {
         return TlsActivationContext->ExecutorThread.RegisterActor<SendingType>(actor, mailboxType, poolId, parentId);
     }
@@ -798,7 +973,31 @@ namespace NActors {
 
     template <ESendingType SendingType>
     bool TActorIdentity::Send(const TActorId& recipient, IEventBase* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const {
-        return TActivationContext::Send<SendingType>(new IEventHandle(recipient, *this, ev, flags, cookie, nullptr, std::move(traceId)));
+        return TActivationContext::Send<SendingType>(new IEventHandleFat(recipient, *this, ev, flags, cookie, nullptr, std::move(traceId)));
+    }
+
+    template <ESendingType SendingType>
+    bool TActorIdentity::Send(const TActorId& recipient, IEventHandleLight* ev) const {
+        ev->PrepareSend(recipient, *this);
+        return TActivationContext::Send<SendingType>(ev);
+    }
+
+    template <ESendingType SendingType>
+    bool TActorIdentity::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags) const {
+        ev->PrepareSend(recipient, *this, flags);
+        return TActivationContext::Send<SendingType>(ev);
+    }
+
+    template <ESendingType SendingType>
+    bool TActorIdentity::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie) const {
+        ev->PrepareSend(recipient, *this, flags, cookie);
+        return TActivationContext::Send<SendingType>(ev);
+    }
+
+    template <ESendingType SendingType>
+    bool TActorIdentity::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) const {
+        ev->PrepareSend(recipient, *this, flags, cookie, std::move(traceId));
+        return TActivationContext::Send<SendingType>(ev);
     }
 
     template <ESendingType SendingType>
diff --git a/library/cpp/actors/core/actor_bootstrapped.h b/library/cpp/actors/core/actor_bootstrapped.h
index 9d89afcf709..37286d48e28 100644
--- a/library/cpp/actors/core/actor_bootstrapped.h
+++ b/library/cpp/actors/core/actor_bootstrapped.h
@@ -12,7 +12,7 @@ namespace NActors {
     class TActorBootstrapped: public TActor<TDerived> {
     protected:
         TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override {
-            return new IEventHandle(TEvents::TSystem::Bootstrap, 0, self, parentId, {}, 0);
+            return new IEventHandleFat(TEvents::TSystem::Bootstrap, 0, self, parentId, {}, 0);
         }
 
         STFUNC(StateBootstrap) {
diff --git a/library/cpp/actors/core/actor_coroutine.cpp b/library/cpp/actors/core/actor_coroutine.cpp
index 48c6f4d2d0a..6b55228bd75 100644
--- a/library/cpp/actors/core/actor_coroutine.cpp
+++ b/library/cpp/actors/core/actor_coroutine.cpp
@@ -44,7 +44,7 @@ namespace NActors {
     THolder<IEventHandle> TActorCoroImpl::WaitForEvent(TInstant deadline) {
         const ui64 cookie = ++WaitCookie;
         if (deadline != TInstant::Max()) {
-            TActivationContext::Schedule(deadline, new IEventHandle(TEvents::TSystem::CoroTimeout, 0, SelfActorId, {}, 0, cookie));
+            TActivationContext::Schedule(deadline, new IEventHandleFat(TEvents::TSystem::CoroTimeout, 0, SelfActorId, {}, 0, cookie));
         }
 
         // ensure we have no unprocessed event and return back to actor system to receive one
diff --git a/library/cpp/actors/core/actor_coroutine.h b/library/cpp/actors/core/actor_coroutine.h
index fc9ddeef1f8..9fca8598f18 100644
--- a/library/cpp/actors/core/actor_coroutine.h
+++ b/library/cpp/actors/core/actor_coroutine.h
@@ -115,6 +115,11 @@ namespace NActors {
 
         bool Send(TAutoPtr<IEventHandle> ev);
 
+        bool Forward(THolder<IEventHandle>& ev, const TActorId& recipient) {
+            IEventHandle::Forward(ev, recipient);
+            return Send(ev.Release());
+        }
+
         void Schedule(TDuration delta, IEventBase* ev, ISchedulerCookie* cookie = nullptr) {
             return GetActorContext().Schedule(delta, ev, cookie);
         }
@@ -157,7 +162,7 @@ namespace NActors {
         {}
 
         TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parent) override {
-            return new IEventHandle(TEvents::TSystem::Bootstrap, 0, self, parent, {}, 0);
+            return new IEventHandleFat(TEvents::TSystem::Bootstrap, 0, self, parent, {}, 0);
         }
 
     private:
diff --git a/library/cpp/actors/core/actor_ut.cpp b/library/cpp/actors/core/actor_ut.cpp
index 86b19af546e..fe492e531e3 100644
--- a/library/cpp/actors/core/actor_ut.cpp
+++ b/library/cpp/actors/core/actor_ut.cpp
@@ -82,7 +82,7 @@ Y_UNIT_TEST_SUITE(ActorBenchmark) {
                 ctx.RegisterWithSameMailbox(new TDummyActor());
             }
             if (Role == ERole::Leader) {
-                TAutoPtr<IEventHandle> ev = new IEventHandle(Receiver, SelfId(), new TEvents::TEvPing());
+                TAutoPtr<IEventHandle> ev = new IEventHandleFat(Receiver, SelfId(), new TEvents::TEvPing());
                 SpecialSend(ev, ctx);
             }
         }
@@ -105,7 +105,7 @@ Y_UNIT_TEST_SUITE(ActorBenchmark) {
             }
 
             if (AllocatesMemory) {
-                SpecialSend(new IEventHandle(ev->Sender, SelfId(), new TEvents::TEvPing()), ctx);
+                SpecialSend(new IEventHandleFat(ev->Sender, SelfId(), new TEvents::TEvPing()), ctx);
             } else {
                 std::swap(*const_cast<TActorId*>(&ev->Sender), *const_cast<TActorId*>(&ev->Recipient));
                 ev->DropRewrite();
@@ -541,14 +541,14 @@ Y_UNIT_TEST_SUITE(TestDecorator) {
         {
         }
 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) override {
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext&) override {
             *Counter += 1;
             if (ev->Type != TEvents::THelloWorld::Pong) {
-                TAutoPtr<IEventHandle> pingEv = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvPing());
+                TAutoPtr<IEventHandle> pingEv = new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvPing());
                 SavedEvent = ev;
-                Actor->Receive(pingEv, ctx);
+                Actor->Receive(pingEv);
             } else {
-                Actor->Receive(SavedEvent, ctx);
+                Actor->Receive(SavedEvent);
             }
             return false;
         }
@@ -566,7 +566,7 @@ Y_UNIT_TEST_SUITE(TestDecorator) {
         bool DoBeforeReceiving(TAutoPtr<IEventHandle>& ev, const TActorContext&) override {
             *Counter += 1;
             if (ev->Type == TEvents::THelloWorld::Ping) {
-                TAutoPtr<IEventHandle> pongEv = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvPong());
+                TAutoPtr<IEventHandle> pongEv = new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvPong());
                 Send(SelfId(), new TEvents::TEvPong());
                 return false;
             }
@@ -701,7 +701,7 @@ Y_UNIT_TEST_SUITE(TestStateFunc) {
         auto sender = runtime.AllocateEdgeActor();
         auto testActor = runtime.Register(new TTestActorWithExceptionsStateFunc());
         for (ui64 tag = 0; tag < 4; ++tag) {
-            runtime.Send(new IEventHandle(testActor, sender, new TEvents::TEvWakeup(tag)), 0, true);
+            runtime.Send(new IEventHandleFat(testActor, sender, new TEvents::TEvWakeup(tag)), 0, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
             UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Tag, tag);
         }
diff --git a/library/cpp/actors/core/actor_virtual.h b/library/cpp/actors/core/actor_virtual.h
index c9c34c4729d..1306252b58d 100644
--- a/library/cpp/actors/core/actor_virtual.h
+++ b/library/cpp/actors/core/actor_virtual.h
@@ -8,7 +8,7 @@ template <class TEvent>
 class TEventContext {
 private:
     TEvent* Event;
-    std::unique_ptr<IEventHandle> Handle;
+    std::unique_ptr<IEventHandleFat> Handle;
 public:
     const TEvent* operator->() const {
         return Event;
@@ -16,7 +16,7 @@ public:
     const IEventHandle& GetHandle() const {
         return *Handle;
     }
-    TEventContext(std::unique_ptr<IEventHandle> handle)
+    TEventContext(std::unique_ptr<IEventHandleFat> handle)
         : Handle(std::move(handle))
     {
         Y_VERIFY_DEBUG(dynamic_cast<TEvent*>(Handle->GetBase()));
@@ -28,7 +28,7 @@ public:
 template <class TEvent, class TExpectedActor>
 class IEventForActor: public IEventBase {
 protected:
-    virtual bool DoExecute(IActor* actor, std::unique_ptr<IEventHandle> eventPtr) override {
+    virtual bool DoExecute(IActor* actor, std::unique_ptr<IEventHandleFat> eventPtr) override {
         Y_VERIFY_DEBUG(dynamic_cast<TExpectedActor*>(actor));
         auto* actorCorrect = static_cast<TExpectedActor*>(actor);
         TEventContext<TEvent> context(std::move(eventPtr));
@@ -41,7 +41,7 @@ public:
 template <class TBaseEvent, class TEvent, class TExpectedObject>
 class IEventForAnything: public TBaseEvent {
 protected:
-    virtual bool DoExecute(IActor* actor, std::unique_ptr<IEventHandle> eventPtr) override {
+    virtual bool DoExecute(IActor* actor, std::unique_ptr<IEventHandleFat> eventPtr) override {
         auto* objImpl = dynamic_cast<TExpectedObject*>(actor);
         if (!objImpl) {
             return false;
diff --git a/library/cpp/actors/core/actorsystem.cpp b/library/cpp/actors/core/actorsystem.cpp
index 1ba4852f538..b33861a9668 100644
--- a/library/cpp/actors/core/actorsystem.cpp
+++ b/library/cpp/actors/core/actorsystem.cpp
@@ -74,7 +74,7 @@ namespace NActors {
 
         if (recpNodeId != NodeId && recpNodeId != 0) {
             // if recipient is not local one - rewrite with forward instruction
-            Y_VERIFY_DEBUG(!ev->HasEvent() || ev->GetBase()->IsSerializable());
+            //Y_VERIFY_DEBUG(!ev->HasEvent() || ev->GetBase()->IsSerializable());
             Y_VERIFY(ev->Recipient == recipient,
                 "Event rewrite from %s to %s would be lost via interconnect",
                 ev->Recipient.ToString().c_str(),
@@ -96,7 +96,7 @@ namespace NActors {
                 }
                 if (target != actorId) {
                     // a race has occured, terminate newly created actor
-                    Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
+                    Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
                 }
             }
             recipient = target;
@@ -110,8 +110,9 @@ namespace NActors {
                 return true;
             }
         }
-
-        Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+        if (ev) {
+            Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
+        }
         return false;
     }
 
@@ -121,7 +122,7 @@ namespace NActors {
     bool TActorSystem::GenericSend<&IExecutorPool::SpecificSend>(TAutoPtr<IEventHandle> ev) const;
 
     bool TActorSystem::Send(const TActorId& recipient, IEventBase* ev, ui32 flags, ui64 cookie) const {
-        return this->Send(new IEventHandle(recipient, DefSelfID, ev, flags, cookie));
+        return this->Send(new IEventHandleFat(recipient, DefSelfID, ev, flags, cookie));
     }
 
     bool TActorSystem::SpecificSend(TAutoPtr<IEventHandle> ev) const {
@@ -139,6 +140,14 @@ namespace NActors {
         }
     }
 
+    bool TActorSystem::Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags, ui64 cookie) const {
+        return this->Send(ev->PrepareSend(recipient, DefSelfID, flags, cookie));
+    }
+
+    bool TActorSystem::Send(const TActorId& recipient, const TActorId& sender, IEventHandleLight* ev, ui32 flags, ui64 cookie) const {
+        return this->Send(ev->PrepareSend(recipient, sender, flags, cookie));
+    }
+
     void TActorSystem::Schedule(TInstant deadline, TAutoPtr<IEventHandle> ev, ISchedulerCookie* cookie) const {
         Schedule(deadline - Timestamp(), ev, cookie);
     }
diff --git a/library/cpp/actors/core/actorsystem.h b/library/cpp/actors/core/actorsystem.h
index 7002a9f44e8..b506a1e3601 100644
--- a/library/cpp/actors/core/actorsystem.h
+++ b/library/cpp/actors/core/actorsystem.h
@@ -204,6 +204,8 @@ namespace NActors {
         bool SpecificSend(TAutoPtr<IEventHandle> ev) const;
 
         bool Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0) const;
+        bool Send(const TActorId& recipient, IEventHandleLight* ev, ui32 flags = 0, ui64 cookie = 0) const;
+        bool Send(const TActorId& recipient, const TActorId& sender, IEventHandleLight* ev, ui32 flags = 0, ui64 cookie = 0) const;
 
         /**
          * Schedule one-shot event that will be send at given time point in the future.
diff --git a/library/cpp/actors/core/ask.cpp b/library/cpp/actors/core/ask.cpp
index 821c7606d4d..e3fe6d9ee3f 100644
--- a/library/cpp/actors/core/ask.cpp
+++ b/library/cpp/actors/core/ask.cpp
@@ -47,9 +47,9 @@ namespace NActors {
                 if (ev->GetTypeRewrite() == TTimeout::EventType) {
                     Promise_.SetException(std::make_exception_ptr(yexception() << "ask timeout"));
                 } else if (!ExpectedEventType_ || ev->GetTypeRewrite() == ExpectedEventType_) {
-                    Promise_.SetValue(ev->ReleaseBase());
+                    Promise_.SetValue(IEventHandleFat::GetFat(ev.Get())->ReleaseBase());
                 } else {
-                    Promise_.SetException(std::make_exception_ptr(yexception() << "received unexpected response " << ev->GetBase()->ToString()));
+                    Promise_.SetException(std::make_exception_ptr(yexception() << "received unexpected response " << IEventHandleFat::GetFat(ev.Get())->GetBase()->ToString()));
                 }
 
                 PassAway();
diff --git a/library/cpp/actors/core/av_bootstrapped.cpp b/library/cpp/actors/core/av_bootstrapped.cpp
index 771177242ec..e1123027926 100644
--- a/library/cpp/actors/core/av_bootstrapped.cpp
+++ b/library/cpp/actors/core/av_bootstrapped.cpp
@@ -7,7 +7,7 @@ public:
 };
 
 TAutoPtr<NActors::IEventHandle> TActorAutoStart::AfterRegister(const TActorId& self, const TActorId& parentId) {
-    return new IEventHandle(self, parentId, new TEventForStart, 0);
+    return new IEventHandleFat(self, parentId, new TEventForStart, 0);
 }
 
 void TActorAutoStart::ProcessEvent(TEventContext<TEventForStart>& ev) {
diff --git a/library/cpp/actors/core/event.cpp b/library/cpp/actors/core/event.cpp
index 6a5230f825e..b963dfb4ea0 100644
--- a/library/cpp/actors/core/event.cpp
+++ b/library/cpp/actors/core/event.cpp
@@ -7,7 +7,79 @@ namespace NActors {
         Max<ui64>(), Max<ui64>()
     };
 
-    TIntrusivePtr<TEventSerializedData> IEventHandle::ReleaseChainBuffer() {
+    TAutoPtr<IEventHandle>& IEventHandle::Forward(TAutoPtr<IEventHandle>& ev, TActorId recipient) {
+        if (ev->IsEventLight()) {
+            IEventHandleLight::GetLight(ev.Get())->Forward(recipient);
+        } else {
+            ev = IEventHandleFat::GetFat(ev.Get())->Forward(recipient);
+        }
+        return ev;
+    }
+
+    THolder<IEventHandle>& IEventHandle::Forward(THolder<IEventHandle>& ev, TActorId recipient) {
+        if (ev->IsEventLight()) {
+            IEventHandleLight::GetLight(ev.Get())->Forward(recipient);
+        } else {
+            ev = IEventHandleFat::GetFat(ev.Get())->Forward(recipient);
+        }
+        return ev;
+    }
+
+    TString IEventHandle::GetTypeName() const {
+        if (IsEventFat()) {
+            auto* ev = const_cast<IEventHandleFat*>(static_cast<const IEventHandleFat*>(this));
+            return ev->HasEvent() ? TypeName(*(ev->GetBase())) : TypeName(*this);
+        } else {
+            return TypeName(*this);
+        }
+    }
+
+    TString IEventHandle::ToString() const {
+        if (IsEventFat()) {
+            auto* ev = const_cast<IEventHandleFat*>(static_cast<const IEventHandleFat*>(this));
+            return ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?";
+        } else {
+            // TODO(xenoxeno):
+            return TypeName(*this);
+        }
+    }
+
+    bool IEventHandle::HasEvent() const {
+        if (IsEventLight()) {
+            return true;
+        } else {
+            return IEventHandleFat::GetFat(this)->HasEvent();
+        }
+    }
+
+    bool IEventHandle::HasBuffer() const {
+        if (IsEventLight()) {
+            return false;
+        } else {
+            return IEventHandleFat::GetFat(this)->HasBuffer();
+        }
+    }
+
+    TActorId IEventHandle::GetForwardOnNondeliveryRecipient() const {
+        if (IsEventLight()) {
+            return {};
+        } else {
+            return IEventHandleFat::GetFat(this)->GetForwardOnNondeliveryRecipient();
+        }
+    }
+
+    size_t IEventHandle::GetSize() const {
+        if (IsEventLight()) {
+            if (IsEventSerializable()) {
+                return IEventHandleLightSerializable::GetLightSerializable(this)->GetSize();
+            }
+        } else {
+            return IEventHandleFat::GetFat(this)->GetSize();
+        }
+        return 0;
+    }
+
+    TIntrusivePtr<TEventSerializedData> IEventHandleFat::ReleaseChainBuffer() {
         if (Buffer) {
             TIntrusivePtr<TEventSerializedData> result;
             DoSwap(result, Buffer);
@@ -24,7 +96,7 @@ namespace NActors {
         return new TEventSerializedData;
     }
 
-    TIntrusivePtr<TEventSerializedData> IEventHandle::GetChainBuffer() {
+    TIntrusivePtr<TEventSerializedData> IEventHandleFat::GetChainBuffer() {
         if (Buffer) {
             return Buffer;
         }
@@ -36,4 +108,6 @@ namespace NActors {
         }
         return new TEventSerializedData;
     }
+
+    std::vector<std::vector<IEventFactory*>*> TEventFactories::EventFactories;
 }
diff --git a/library/cpp/actors/core/event.h b/library/cpp/actors/core/event.h
index 4eedeb0574a..28e2c95e000 100644
--- a/library/cpp/actors/core/event.h
+++ b/library/cpp/actors/core/event.h
@@ -9,6 +9,7 @@
 
 #include <util/system/hp_timer.h>
 #include <util/generic/maybe.h>
+#include <util/string/builder.h>
 
 namespace NActors {
     class TChunkSerializer;
@@ -23,7 +24,7 @@ namespace NActors {
           public ISerializerToStream {
     protected:
         // for compatibility with virtual actors
-        virtual bool DoExecute(IActor* /*actor*/, std::unique_ptr<IEventHandle> /*eventPtr*/) {
+        virtual bool DoExecute(IActor* /*actor*/, std::unique_ptr<IEventHandleFat> /*eventPtr*/) {
             Y_VERIFY_DEBUG(false);
             return false;
         }
@@ -33,7 +34,7 @@ namespace NActors {
         virtual ~IEventBase() {
         }
 
-        bool Execute(IActor* actor, std::unique_ptr<IEventHandle> eventPtr) {
+        bool Execute(IActor* actor, std::unique_ptr<IEventHandleFat> eventPtr) {
             return DoExecute(actor, std::move(eventPtr));
         }
 
@@ -53,8 +54,70 @@ namespace NActors {
         virtual TEventSerializationInfo CreateSerializationInfo() const { return {}; }
     };
 
-    // fat handle
-    class IEventHandle : TNonCopyable {
+    struct IEventHandleFields {
+        enum EFlags : ui32 {
+            FlagTrackDelivery = 1 << 0,
+            FlagForwardOnNondelivery = 1 << 1,
+            FlagSubscribeOnSession = 1 << 2,
+            FlagUseSubChannel = 1 << 3,
+            FlagGenerateUnsureUndelivered = 1 << 4,
+            FlagExtendedFormat = 1 << 5,
+            FlagLight = 1 << 18,
+            FlagSerializable = 1 << 19,
+        };
+
+        static constexpr ui32 STICKY_FLAGS = (FlagLight | FlagSerializable);
+
+        TActorId Recipient = {};
+        TActorId Sender = {};
+        ui32 Type = {};
+
+#pragma pack(push, 1)
+        union {
+            ui32 Flags = {};
+            struct {
+                ui32 NormalFlags:6;
+                ui32 ReservedFlags:12;
+                ui32 StickyFlags:2;
+                ui32 Channel:12;
+            };
+            struct {
+                // flags
+                ui32 TrackDelivery:1;
+                ui32 ForwardOnNondeliveryFlag:1;
+                ui32 SubscribeOnSession:1;
+                ui32 UseSubChannel:1;
+                ui32 GenerateUnsureUndelivered:1;
+                ui32 ExtendedFormat:1;
+                // reserved
+                ui32 Reserved:12;
+                // sticky flags
+                ui32 Light:1;
+                ui32 Serializable:1;
+            };
+        };
+#pragma pack(pop)
+
+        ui64 Cookie = {};
+
+        TActorId RewriteRecipient = {};
+        ui32 RewriteType = {};
+
+        NWilson::TTraceId TraceId = {};
+
+#ifdef ACTORSLIB_COLLECT_EXEC_STATS
+        ::NHPTimer::STime SendTime = 0;
+#endif
+    };
+
+    class IEventHandle : public IEventHandleFields {
+    public:
+        IEventHandle(IEventHandleFields&& fields = {})
+            : IEventHandleFields(std::move(fields))
+        {}
+
+        virtual ~IEventHandle() = default;
+
         struct TOnNondelivery {
             TActorId Recipient;
 
@@ -64,28 +127,142 @@ namespace NActors {
             }
         };
 
+        THolder<TOnNondelivery> OnNondeliveryHolder; // only for local events
+
+        ui16 GetChannel() const noexcept {
+            return Channel;
+        }
+
+        ui64 GetSubChannel() const noexcept {
+            return UseSubChannel ? Sender.LocalId() : 0ULL;
+        }
+
+        // deprecate(xenoxeno) ?
+        static const size_t ChannelBits = 12;
+        static const size_t ChannelShift = (sizeof(ui32) << 3) - ChannelBits;
+
+        static ui32 MakeFlags(ui32 channel, ui32 flags) {
+            Y_VERIFY(channel < (1 << ChannelBits));
+            Y_VERIFY(flags < (1 << ChannelShift));
+            return (flags | (channel << ChannelShift));
+        }
+        //
+
+        void SetFlags(ui32 flags) {
+            Flags = (flags & ~STICKY_FLAGS) | (Flags & STICKY_FLAGS);
+        }
+
+        const TActorId& GetRecipientRewrite() const {
+            return RewriteRecipient;
+        }
+
+        void Rewrite(ui32 typeRewrite, TActorId recipientRewrite) {
+            RewriteRecipient = recipientRewrite;
+            RewriteType = typeRewrite;
+        }
+
+        void DropRewrite() {
+            RewriteRecipient = Recipient;
+            RewriteType = Type;
+        }
+
+        ui32 GetTypeRewrite() const {
+            return RewriteType;
+        }
+
+        bool IsEventLight() const {
+            return Light;
+        }
+
+        bool IsEventFat() const {
+            return !Light;
+        }
+
+        bool IsEventSerializable() const {
+            return Serializable;
+        }
+
+        template<typename TEventType>
+        TEventType* Get();
+        template<typename TEventType>
+        TEventType* CastAsLocal();
+        template<typename TEventType>
+        TEventType* StaticCastAsLocal();
+        bool HasEvent() const;
+        bool HasBuffer() const;
+        TString GetTypeName() const;
+        TString ToString() const;
+        size_t GetSize() const;
+        static TAutoPtr<IEventHandle>& Forward(TAutoPtr<IEventHandle>& ev, TActorId recipient);
+        static THolder<IEventHandle>& Forward(THolder<IEventHandle>& ev, TActorId recipient);
+        static TAutoPtr<IEventHandle> ForwardOnNondelivery(TAutoPtr<IEventHandle>& ev, ui32 reason, bool unsure = false);
+        static TAutoPtr<IEventHandle> ForwardOnNondelivery(std::unique_ptr<IEventHandle>& ev, ui32 reason, bool unsure = false);
+        template<typename TEventType>
+        static TEventType* Release(TAutoPtr<IEventHandle>&);
+        template<typename TEventType>
+        static TEventType* Release(THolder<IEventHandle>&);
+        template<typename TEventType>
+        static TEventType* Release(std::unique_ptr<IEventHandle>&);
+
+        template<typename TEventTypeSmartPtr>
+        static TAutoPtr<IEventHandle> ForwardOnNondelivery(TEventTypeSmartPtr& ev, ui32 reason, bool unsure = false) {
+            TAutoPtr<IEventHandle> evi(ev.Release());
+            return ForwardOnNondelivery(evi, reason, unsure);
+        }
+
+        TActorId GetForwardOnNondeliveryRecipient() const;
+    };
+
+    // fat handle
+    class IEventHandleFat : public IEventHandle, TNonCopyable {
     public:
         template <typename TEv>
-        inline TEv* CastAsLocal() const noexcept {
+        inline TEv* CastAsLocal() const noexcept { // cast with event check
             auto fits = GetTypeRewrite() == TEv::EventType;
+            constexpr bool couldBeCasted = requires() {static_cast<TEv*>(Event.Get());};
+            if constexpr (couldBeCasted) {
+                return fits ? static_cast<TEv*>(Event.Get()) : nullptr;
+            } else {
+                Y_FAIL("Event type %" PRIu32 " couldn't be converted to type %s", Type, TypeName<TEv>().data());
+            }
+        }
 
-            return fits ? static_cast<TEv*>(Event.Get()) : nullptr;
+        template <typename TEv>
+        inline TEv* StaticCastAsLocal() const noexcept { // blind cast
+            constexpr bool couldBeCasted = requires() {static_cast<TEv*>(Event.Get());};
+            if constexpr (couldBeCasted) {
+                return static_cast<TEv*>(Event.Get());
+            } else {
+                Y_FAIL("Event type %" PRIu32 " couldn't be converted to type %s", Type, TypeName<TEv>().data());
+            }
         }
 
         template <typename TEventType>
         TEventType* Get() {
             if (Type != TEventType::EventType)
-                Y_FAIL("Event type %" PRIu32 " doesn't match the expected type %" PRIu32, Type, TEventType::EventType);
+                Y_FAIL("%s", (TStringBuilder()
+                    << "Event type " << Type
+                    << " doesn't match the expected type " << TEventType::EventType
+                    << " requested typename " << TypeName<TEventType>()
+                    << " actual typename " << GetTypeName()).data());
 
-            if (!Event) {
+            constexpr bool couldBeGot = requires() {
                 Event.Reset(TEventType::Load(Buffer.Get()));
+                static_cast<TEventType*>(Event.Get());
+            };
+            if constexpr (couldBeGot) {
+                if (!Event) {
+                    Event.Reset(TEventType::Load(Buffer.Get()));
+                }
+
+                if (Event) {
+                    return static_cast<TEventType*>(Event.Get());
+                }
+
+                Y_FAIL("Failed to Load() event type %" PRIu32 " class %s", Type, TypeName<TEventType>().data());
+            } else {
+                Y_FAIL("Event type %" PRIu32 " couldn't be get as type %s", Type, TypeName<TEventType>().data());
             }
-
-            if (Event) {
-                return static_cast<TEventType*>(Event.Get());
-            }
-
-            Y_FAIL("Failed to Load() event type %" PRIu32 " class %s", Type, TypeName<TEventType>().data());
         }
 
         template <typename T>
@@ -96,104 +273,43 @@ namespace NActors {
             return x;
         }
 
-        enum EFlags {
-            FlagTrackDelivery = 1 << 0,
-            FlagForwardOnNondelivery = 1 << 1,
-            FlagSubscribeOnSession = 1 << 2,
-            FlagUseSubChannel = 1 << 3,
-            FlagGenerateUnsureUndelivered = 1 << 4,
-            FlagExtendedFormat = 1 << 5,
-        };
-
-        const ui32 Type;
-        const ui32 Flags;
-        const TActorId Recipient;
-        const TActorId Sender;
-        const ui64 Cookie;
         const TScopeId OriginScopeId = TScopeId::LocallyGenerated; // filled in when the message is received from Interconnect
 
-        // if set, used by ActorSystem/Interconnect to report tracepoints
-        NWilson::TTraceId TraceId;
-
         // filled if feeded by interconnect session
         const TActorId InterconnectSession;
 
-#ifdef ACTORSLIB_COLLECT_EXEC_STATS
-        ::NHPTimer::STime SendTime;
-#endif
-
-        static const size_t ChannelBits = 12;
-        static const size_t ChannelShift = (sizeof(ui32) << 3) - ChannelBits;
 
 #ifdef USE_ACTOR_CALLSTACK
         TCallstack Callstack;
 #endif
-        ui16 GetChannel() const noexcept {
-            return Flags >> ChannelShift;
-        }
-
-        ui64 GetSubChannel() const noexcept {
-            return Flags & FlagUseSubChannel ? Sender.LocalId() : 0ULL;
-        }
-
-        static ui32 MakeFlags(ui32 channel, ui32 flags) {
-            Y_VERIFY(channel < (1 << ChannelBits));
-            Y_VERIFY(flags < (1 << ChannelShift));
-            return (flags | (channel << ChannelShift));
-        }
-
     private:
         THolder<IEventBase> Event;
         TIntrusivePtr<TEventSerializedData> Buffer;
 
-        TActorId RewriteRecipient;
-        ui32 RewriteType;
-
-        THolder<TOnNondelivery> OnNondeliveryHolder; // only for local events
-
     public:
-        void Rewrite(ui32 typeRewrite, TActorId recipientRewrite) {
-            RewriteRecipient = recipientRewrite;
-            RewriteType = typeRewrite;
-        }
-
-        void DropRewrite() {
-            RewriteRecipient = Recipient;
-            RewriteType = Type;
-        }
-
-        const TActorId& GetRecipientRewrite() const {
-            return RewriteRecipient;
-        }
-
-        ui32 GetTypeRewrite() const {
-            return RewriteType;
-        }
-
         TActorId GetForwardOnNondeliveryRecipient() const {
             return OnNondeliveryHolder.Get() ? OnNondeliveryHolder->Recipient : TActorId();
         }
 
-        IEventHandle(const TActorId& recipient, const TActorId& sender, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0,
+        IEventHandleFat(const TActorId& recipient, const TActorId& sender, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0,
                      const TActorId* forwardOnNondelivery = nullptr, NWilson::TTraceId traceId = {})
-            : Type(ev->Type())
-            , Flags(flags)
-            , Recipient(recipient)
-            , Sender(sender)
-            , Cookie(cookie)
-            , TraceId(std::move(traceId))
-#ifdef ACTORSLIB_COLLECT_EXEC_STATS
-            , SendTime(0)
-#endif
+            : IEventHandle({
+                .Recipient = recipient,
+                .Sender = sender,
+                .Type = ev->Type(),
+                .Flags = flags,
+                .Cookie = cookie,
+                .RewriteRecipient = recipient,
+                .RewriteType = ev->Type(),
+                .TraceId = std::move(traceId),
+            })
             , Event(ev)
-            , RewriteRecipient(Recipient)
-            , RewriteType(Type)
         {
             if (forwardOnNondelivery)
                 OnNondeliveryHolder.Reset(new TOnNondelivery(*forwardOnNondelivery));
         }
 
-        IEventHandle(ui32 type,
+        IEventHandleFat(ui32 type,
                      ui32 flags,
                      const TActorId& recipient,
                      const TActorId& sender,
@@ -201,25 +317,24 @@ namespace NActors {
                      ui64 cookie,
                      const TActorId* forwardOnNondelivery = nullptr,
                      NWilson::TTraceId traceId = {})
-            : Type(type)
-            , Flags(flags)
-            , Recipient(recipient)
-            , Sender(sender)
-            , Cookie(cookie)
-            , TraceId(std::move(traceId))
-#ifdef ACTORSLIB_COLLECT_EXEC_STATS
-            , SendTime(0)
-#endif
+            : IEventHandle({
+                .Recipient = recipient,
+                .Sender = sender,
+                .Type = type,
+                .Flags = flags,
+                .Cookie = cookie,
+                .RewriteRecipient = recipient,
+                .RewriteType = type,
+                .TraceId = std::move(traceId),
+            })
             , Buffer(std::move(buffer))
-            , RewriteRecipient(Recipient)
-            , RewriteType(Type)
         {
             if (forwardOnNondelivery)
                 OnNondeliveryHolder.Reset(new TOnNondelivery(*forwardOnNondelivery));
         }
 
         // Special ctor for events from interconnect.
-        IEventHandle(const TActorId& session,
+        IEventHandleFat(const TActorId& session,
                      ui32 type,
                      ui32 flags,
                      const TActorId& recipient,
@@ -228,20 +343,19 @@ namespace NActors {
                      ui64 cookie,
                      TScopeId originScopeId,
                      NWilson::TTraceId traceId) noexcept
-            : Type(type)
-            , Flags(flags)
-            , Recipient(recipient)
-            , Sender(sender)
-            , Cookie(cookie)
+            : IEventHandle({
+                .Recipient = recipient,
+                .Sender = sender,
+                .Type = type,
+                .Flags = flags,
+                .Cookie = cookie,
+                .RewriteRecipient = recipient,
+                .RewriteType = type,
+                .TraceId = std::move(traceId),
+            })
             , OriginScopeId(originScopeId)
-            , TraceId(std::move(traceId))
             , InterconnectSession(session)
-#ifdef ACTORSLIB_COLLECT_EXEC_STATS
-            , SendTime(0)
-#endif
             , Buffer(std::move(buffer))
-            , RewriteRecipient(Recipient)
-            , RewriteType(Type)
         {
         }
 
@@ -286,28 +400,267 @@ namespace NActors {
 
         TAutoPtr<IEventHandle> Forward(const TActorId& dest) {
             if (Event)
-                return new IEventHandle(dest, Sender, Event.Release(), Flags, Cookie, nullptr, std::move(TraceId));
+                return new IEventHandleFat(dest, Sender, Event.Release(), Flags, Cookie, nullptr, std::move(TraceId));
             else
-                return new IEventHandle(Type, Flags, dest, Sender, Buffer, Cookie, nullptr, std::move(TraceId));
+                return new IEventHandleFat(Type, Flags, dest, Sender, Buffer, Cookie, nullptr, std::move(TraceId));
+        }
+
+        static TAutoPtr<IEventHandleFat> MakeFat(TAutoPtr<IEventHandle> ev) {
+            if (ev->IsEventLight()) {
+                Y_FAIL("Can't make light event fat");
+            } else {
+                TAutoPtr<IEventHandleFat> evb(static_cast<IEventHandleFat*>(ev.Release()));
+                return evb;
+            }
         }
 
-        TAutoPtr<IEventHandle> ForwardOnNondelivery(ui32 reason, bool unsure = false);
+        static IEventHandleFat* GetFat(IEventHandle* ev) {
+            if (ev->IsEventLight()) {
+                Y_FAIL("Can't make light event fat");
+            } else {
+                return static_cast<IEventHandleFat*>(ev);
+            }
+        }
+
+        static const IEventHandleFat* GetFat(const IEventHandle* ev) {
+            if (ev->IsEventLight()) {
+                Y_FAIL("Can't make light event fat");
+            } else {
+                return static_cast<const IEventHandleFat*>(ev);
+            }
+        }
+
+        static IEventHandleFat* GetFat(TAutoPtr<IEventHandle>& ev) {
+            return GetFat(ev.Get());
+        }
+
+        static IEventHandleFat* GetFat(THolder<IEventHandle>& ev) {
+            return GetFat(ev.Get());
+        }
+
+        static IEventHandleFat* GetFat(std::unique_ptr<IEventHandle>& ev) {
+            return GetFat(ev.get());
+        }
+
+        static TAutoPtr<IEventHandle> MakeBase(TAutoPtr<IEventHandleFat> ev) {
+            return ev.Release();
+        }
+
+        static std::unique_ptr<IEventHandle> ForwardOnNondelivery(std::unique_ptr<IEventHandleFat>& ev, ui32 reason, bool unsure = false);
     };
 
     template <typename TEventType>
-    class TEventHandle: public IEventHandle {
-        TEventHandle(); // we never made instance of TEventHandle
+    class TEventHandleFat: public IEventHandleFat {
+        TEventHandleFat(); // we never made instance of TEventHandleFat
     public:
         TEventType* Get() {
-            return IEventHandle::Get<TEventType>();
+            return IEventHandleFat::Get<TEventType>();
         }
 
         TAutoPtr<TEventType> Release() {
-            return IEventHandle::Release<TEventType>();
+            return IEventHandleFat::Release<TEventType>();
+        }
+    };
+
+    static_assert(sizeof(TEventHandleFat<IEventBase>) == sizeof(IEventHandleFat), "expect sizeof(TEventHandleFat<IEventBase>) == sizeof(IEventHandleFat)");
+
+    // light handle
+    class IEventHandleLight : public IEventHandle {
+    public:
+        IEventHandleLight(ui32 type) {
+            RewriteType = Type = type;
+            Light = true;
+        }
+
+        IEventHandleLight* PrepareSend(TActorId recipient, TActorId sender) {
+            RewriteRecipient = Recipient = recipient;
+            Sender = sender;
+            return this;
+        }
+
+        IEventHandleLight* PrepareSend(TActorId recipient, TActorId sender, ui32 flags) {
+            RewriteRecipient = Recipient = recipient;
+            Sender = sender;
+            SetFlags(flags);
+            return this;
+        }
+
+        IEventHandleLight* PrepareSend(TActorId recipient, TActorId sender, ui32 flags, ui64 cookie) {
+            RewriteRecipient = Recipient = recipient;
+            Sender = sender;
+            SetFlags(flags);
+            Cookie = cookie;
+            return this;
+        }
+
+        IEventHandleLight* PrepareSend(TActorId recipient, TActorId sender, ui32 flags, ui64 cookie, NWilson::TTraceId traceId) {
+            RewriteRecipient = Recipient = recipient;
+            Sender = sender;
+            SetFlags(flags);
+            Cookie = cookie;
+            TraceId = std::move(traceId);
+            return this;
+        }
+
+        void Forward(const TActorId& dest) {
+            RewriteRecipient = dest;
+        }
+
+        static IEventHandleLight* GetLight(IEventHandle* ev) {
+            if (ev->IsEventLight()) {
+                return static_cast<IEventHandleLight*>(ev);
+            } else {
+                Y_FAIL("Can't make fat event light");
+            }
+        }
+
+        static IEventHandleLight* GetLight(TAutoPtr<IEventHandle>& ev) {
+            return GetLight(ev.Get());
+        }
+
+        static IEventHandleLight* GetLight(THolder<IEventHandle>& ev) {
+            return GetLight(ev.Get());
+        }
+
+        static IEventHandleLight* GetLight(std::unique_ptr<IEventHandle>& ev) {
+            return GetLight(ev.get());
+        }
+
+        static IEventHandleLight* ReleaseLight(TAutoPtr<IEventHandle>& ev) {
+            return GetLight(ev.Release());
+        }
+
+        static std::unique_ptr<IEventHandle> ForwardOnNondelivery(std::unique_ptr<IEventHandleLight>& ev, ui32 reason, bool unsure = false);
+
+        template<typename TEventType>
+        TEventType* Get() {
+            if (Type != TEventType::EventType) {
+                Y_FAIL("Event type %" PRIu32 " doesn't match the expected type %" PRIu32, Type, TEventType::EventType);
+            }
+            constexpr bool couldBeConverted = requires() {static_cast<TEventType*>(this);};
+            if constexpr (couldBeConverted) {
+                return static_cast<TEventType*>(this);
+            } else {
+                Y_FAIL("Event type %" PRIu32 " couldn't be converted to type %s", Type, TypeName<TEventType>().data());
+            }
+        }
+
+        template<typename TEventType>
+        TEventType* CastAsLocal() {
+            constexpr bool couldBeConverted = requires() {static_cast<TEventType*>(this);};
+            if constexpr (couldBeConverted) {
+                if (Type == TEventType::EventType) {
+                    return static_cast<TEventType*>(this);
+                }
+            }
+            return nullptr;
+        }
+
+        template<typename TEventType>
+        TEventType* StaticCastAsLocal() {
+            constexpr bool couldBeConverted = requires() {static_cast<TEventType*>(this);};
+            if constexpr (couldBeConverted) {
+                return static_cast<TEventType*>(this);
+            }
+            Y_FAIL("Event type %" PRIu32 " couldn't be converted to type %s", Type, TypeName<TEventType>().data());
         }
     };
 
-    static_assert(sizeof(TEventHandle<IEventBase>) == sizeof(IEventHandle), "expect sizeof(TEventHandle<IEventBase>) == sizeof(IEventHandle)");
+    template<typename TEventType>
+    TEventType* IEventHandle::Get() {
+        if (IsEventLight()) {
+            return IEventHandleLight::GetLight(this)->Get<TEventType>();
+        } else {
+            return IEventHandleFat::GetFat(this)->Get<TEventType>();
+        }
+    }
+
+    template<typename TEventType>
+    TEventType* IEventHandle::CastAsLocal() {
+        if (IsEventLight()) {
+            return IEventHandleLight::GetLight(this)->CastAsLocal<TEventType>();
+        } else {
+            return IEventHandleFat::GetFat(this)->CastAsLocal<TEventType>();
+        }
+    }
+
+    template<typename TEventType>
+    TEventType* IEventHandle::StaticCastAsLocal() {
+        if (IsEventLight()) {
+            return IEventHandleLight::GetLight(this)->StaticCastAsLocal<TEventType>();
+        } else {
+            return IEventHandleFat::GetFat(this)->StaticCastAsLocal<TEventType>();
+        }
+    }
+
+    template<typename TEventType>
+    TEventType* IEventHandle::Release(TAutoPtr<IEventHandle>& ev) {
+        if (ev->IsEventLight()) {
+            return IEventHandleLight::GetLight(ev.Release())->CastAsLocal<TEventType>();
+        } else {
+            return IEventHandleFat::GetFat(ev.Get())->Release<TEventType>().Release();
+        }
+    }
+
+    template<typename TEventType>
+    TEventType* IEventHandle::Release(THolder<IEventHandle>& ev) {
+        if (ev->IsEventLight()) {
+            return IEventHandleLight::GetLight(ev.Release())->CastAsLocal<TEventType>();
+        } else {
+            return IEventHandleFat::GetFat(ev.Get())->Release<TEventType>().Release();
+        }
+    }
+
+    template<typename TEventType>
+    TEventType* IEventHandle::Release(std::unique_ptr<IEventHandle>& ev) {
+        if (ev->IsEventLight()) {
+            return IEventHandleLight::GetLight(ev.release())->CastAsLocal<TEventType>();
+        } else {
+            return IEventHandleFat::GetFat(ev.get())->Release<TEventType>().Release();
+        }
+    }
+
+
+    class IEventHandleLightSerializable;
+
+    using TEventSerializer = std::function<bool(const IEventHandleLightSerializable*, TChunkSerializer*)>;
+
+    class IEventHandleLightSerializable : public IEventHandleLight {
+    public:
+        TEventSerializer Serializer;
+
+        IEventHandleLightSerializable(ui32 type, TEventSerializer serializer)
+            : IEventHandleLight(type)
+            , Serializer(std::move(serializer))
+        {
+            Serializable = true;
+        }
+
+        static IEventHandleLightSerializable* GetLightSerializable(IEventHandle* ev) {
+            if (ev->IsEventSerializable()) {
+                return static_cast<IEventHandleLightSerializable*>(ev);
+            } else {
+                Y_FAIL("Can't make serializable event");
+            }
+        }
+
+        static const IEventHandleLightSerializable* GetLightSerializable(const IEventHandle* ev) {
+            if (ev->IsEventSerializable()) {
+                return static_cast<const IEventHandleLightSerializable*>(ev);
+            } else {
+                Y_FAIL("Can't make serializable event");
+            }
+        }
+
+        static IEventHandleLightSerializable* GetLightSerializable(TAutoPtr<IEventHandle>& ev) {
+            return GetLightSerializable(ev.Get());
+        }
+
+        size_t GetSize() const {
+            // TODO(xenoxeno)
+            return 0;
+        }
+    };
 
     template <typename TEventType, ui32 EventType0>
     class TEventBase: public IEventBase {
@@ -318,7 +671,7 @@ namespace NActors {
         }
         // still abstract
 
-        typedef TEventHandle<TEventType> THandle;
+        typedef TEventHandleFat<TEventType> THandle;
         typedef TAutoPtr<THandle> TPtr;
     };
 
@@ -327,7 +680,7 @@ namespace NActors {
         return TString(header);                                         \
     }                                                                   \
     bool SerializeToArcadiaStream(NActors::TChunkSerializer*) const override { \
-        Y_FAIL("Local event " #eventType " is not serializable");       \
+        Y_FAIL("Local event %s is not serializable", TypeName(*this).data()); \
     }                                                                   \
     static IEventBase* Load(NActors::TEventSerializedData*) {           \
         Y_FAIL("Local event " #eventType " has no load method");        \
@@ -349,4 +702,39 @@ namespace NActors {
     bool IsSerializable() const override {                              \
         return true;                                                    \
     }
+
+
+    struct TEventMeta {
+        TActorId Session;
+        ui32 Type;
+        ui32 Flags;
+        TActorId Recipient;
+        TActorId Sender;
+        ui64 Cookie;
+        TScopeId OriginScopeId;
+        NWilson::TTraceId TraceId;
+        TRope Data;
+
+        bool IsExtendedFormat() const {
+            return Flags & IEventHandle::FlagExtendedFormat;
+        }
+    };
+
+    inline constexpr ui32 GetEventSpace(ui32 eventType) {
+        return (eventType >> 16u);
+    }
+
+    inline constexpr ui32 GetEventSubType(ui32 eventType) {
+        return (eventType & (0xffff));
+    }
+
+    struct IEventFactory {
+        virtual IEventHandle* Construct(const TEventMeta& eventMeta) = 0;
+        virtual void Destruct(IEventHandle*) = 0;
+    };
+
+    struct TEventFactories {
+        // it supposed to be statically allocated in the begining
+        static std::vector<std::vector<IEventFactory*>*> EventFactories; // [EventSpace][EventSubType]
+    };
 }
diff --git a/library/cpp/actors/core/event_load.h b/library/cpp/actors/core/event_load.h
index 30cc26aa463..b845760221e 100644
--- a/library/cpp/actors/core/event_load.h
+++ b/library/cpp/actors/core/event_load.h
@@ -7,7 +7,7 @@
 #include <library/cpp/actors/wilson/wilson_trace.h>
 
 namespace NActors {
-    class IEventHandle;
+    class IEventHandleFat;
 
     struct TConstIoVec {
         const void* Data;
diff --git a/library/cpp/actors/core/event_local.h b/library/cpp/actors/core/event_local.h
index 2845aa94dd9..5288a65a894 100644
--- a/library/cpp/actors/core/event_local.h
+++ b/library/cpp/actors/core/event_local.h
@@ -71,4 +71,20 @@ namespace NActors {
             return new TEv();
         }
     };
+
+    template<typename TEv, ui32 EventType0>
+    class TEventLight : public IEventHandleLight {
+    public:
+        static constexpr ui32 EventType = EventType0;
+
+        TEventLight()
+            : IEventHandleLight(EventType)
+        {}
+
+        TEv* Get() {
+            return static_cast<TEv*>(this);
+        }
+
+        using TPtr = TAutoPtr<TEv>;
+    };
 }
diff --git a/library/cpp/actors/core/event_pb.h b/library/cpp/actors/core/event_pb.h
index 594559cea78..ed696dc0f90 100644
--- a/library/cpp/actors/core/event_pb.h
+++ b/library/cpp/actors/core/event_pb.h
@@ -9,6 +9,8 @@
 #include <util/generic/deque.h>
 #include <util/system/context.h>
 #include <util/system/filemap.h>
+#include <util/string/builder.h>
+#include <util/thread/lfstack.h>
 #include <array>
 
 namespace NActors {
@@ -511,4 +513,290 @@ namespace NActors {
         dest->SetRawX1(src.RawX1());
         dest->SetRawX2(src.RawX2());
     }
+
+
+
+
+
+
+
+
+
+
+
+    template<ui32 EventSpace>
+    struct TLightEventSpaceFactories {
+    public:
+        static std::vector<IEventFactory*>& GetEventSpaceFactories(ui32 eventSpace) {
+            if (TEventFactories::EventFactories.size() <= eventSpace) {
+                // it's only safe to do BEFORE initialization of ActorSystem
+                TEventFactories::EventFactories.resize(eventSpace + 1);
+            }
+            if (TEventFactories::EventFactories[eventSpace] == nullptr) {
+                TEventFactories::EventFactories[eventSpace] = new std::vector<IEventFactory*>();
+            }
+            return *TEventFactories::EventFactories[eventSpace];
+        }
+
+        static void SetEventFactory(ui32 eventType, IEventFactory* factory) {
+            Y_VERIFY(GetEventSpace(eventType) == EventSpace);
+            auto eventSpaceFactories = GetEventSpaceFactories(GetEventSpace(eventType));
+            if (eventSpaceFactories.size() <= GetEventSubType(eventType)) {
+                // it's only safe to do BEFORE initialization of ActorSystem
+                eventSpaceFactories.resize(GetEventSubType(eventType) + 1);
+            }
+            eventSpaceFactories[GetEventSubType(eventType)] = factory;
+        }
+    };
+
+    template<typename TEvent>
+    class TLightEventFactory : public IEventFactory, TLightEventSpaceFactories<GetEventSpace(TEvent::EventType)> {
+    private:
+        mutable size_t CachedByteSize = 0;
+
+        static constexpr char PayloadMarker = 0x07;
+        static constexpr size_t MaxNumberBytes = (sizeof(size_t) * CHAR_BIT + 6) / 7;
+
+        static size_t SerializeNumber(size_t num, char *buffer) {
+            char *begin = buffer;
+            do {
+                *buffer++ = (num & 0x7F) | (num >= 128 ? 0x80 : 0x00);
+                num >>= 7;
+            } while (num);
+            return buffer - begin;
+        }
+
+        static size_t DeserializeNumber(const char **ptr, const char *end) {
+            const char *p = *ptr;
+            size_t res = 0;
+            size_t offset = 0;
+            for (;;) {
+                if (p == end) {
+                    return Max<size_t>();
+                }
+                const char byte = *p++;
+                res |= (static_cast<size_t>(byte) & 0x7F) << offset;
+                offset += 7;
+                if (!(byte & 0x80)) {
+                    break;
+                }
+            }
+            *ptr = p;
+            return res;
+        }
+
+        static size_t DeserializeNumber(TRope::TConstIterator& iter, ui64& size) {
+            size_t res = 0;
+            size_t offset = 0;
+            for (;;) {
+                if (!iter.Valid()) {
+                    return Max<size_t>();
+                }
+                const char byte = *iter.ContiguousData();
+                iter += 1;
+                --size;
+                res |= (static_cast<size_t>(byte) & 0x7F) << offset;
+                offset += 7;
+                if (!(byte & 0x80)) {
+                    break;
+                }
+            }
+            return res;
+        }
+
+    public:
+        void DeserializeProtoEvent(TEvent* event, const TEventMeta& eventMeta) {
+            TRope::TConstIterator iter = eventMeta.Data.Begin();
+            ui64 size = eventMeta.Data.GetSize();
+            if (eventMeta.IsExtendedFormat()) {
+                constexpr bool hasPayload = requires(const TEvent* e) {e->Payload;};
+                if constexpr (hasPayload) {
+                    // check marker
+                    if (!iter.Valid() || *iter.ContiguousData() != PayloadMarker) {
+                        Y_FAIL("Invalid event marker");
+                    }
+                    // skip marker
+                    iter += 1;
+                    --size;
+                    // parse number of payload ropes
+                    size_t numRopes = DeserializeNumber(iter, size);
+                    if (numRopes == Max<size_t>()) {
+                        Y_FAIL("Invalid event rope number");
+                    }
+                    while (numRopes--) {
+                        // parse length of the rope
+                        const size_t len = DeserializeNumber(iter, size);
+                        if (len == Max<size_t>() || size < len) {
+                            Y_FAIL("%s", (TStringBuilder() << "Invalid event len# " << len << " size# " << size).data());
+                        }
+                        // extract the rope
+                        TRope::TConstIterator begin = iter;
+                        iter += len;
+                        size -= len;
+                        event->Payload.emplace_back(begin, iter);
+                    }
+                } else {
+                    Y_FAIL("%s", (TStringBuilder() << "Extended format is not supported for event " << TypeName<TEvent>()).data());
+                }
+            }
+            // parse the protobuf
+            TRopeStream stream(iter, size);
+            if (!event->Record.ParsePartialFromZeroCopyStream(&stream)) {
+                Y_FAIL("%s", (TStringBuilder() << "Failed to parse protobuf event type " << eventMeta.Type << " class " << TypeName<TEvent>()).data());
+            }
+        }
+
+        static bool SerializeProtoEvent(const TEvent* event, TChunkSerializer* chunker) {
+            constexpr bool hasPayload = requires(const TEvent* e) {e->Payload;};
+            if constexpr (hasPayload) {
+                // serialize payload first
+                if (event->Payload) {
+                    void *data;
+                    int size = 0;
+                    auto append = [&](const char *p, size_t len) {
+                        while (len) {
+                            if (size) {
+                                const size_t numBytesToCopy = std::min<size_t>(size, len);
+                                memcpy(data, p, numBytesToCopy);
+                                data = static_cast<char*>(data) + numBytesToCopy;
+                                size -= numBytesToCopy;
+                                p += numBytesToCopy;
+                                len -= numBytesToCopy;
+                            } else if (!chunker->Next(&data, &size)) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    };
+                    auto appendNumber = [&](size_t number) {
+                        char buf[MaxNumberBytes];
+                        return append(buf, SerializeNumber(number, buf));
+                    };
+                    char marker = PayloadMarker;
+                    append(&marker, 1);
+                    if (!appendNumber(event->Payload.size())) {
+                        return false;
+                    }
+                    for (const TRope& rope : event->Payload) {
+                        if (!appendNumber(rope.GetSize())) {
+                            return false;
+                        }
+                        if (rope) {
+                            if (size) {
+                                chunker->BackUp(std::exchange(size, 0));
+                            }
+                            if (!chunker->WriteRope(&rope)) {
+                                return false;
+                            }
+                        }
+                    }
+                    if (size) {
+                        chunker->BackUp(size);
+                    }
+                }
+            }
+            return event->Record.SerializeToZeroCopyStream(chunker);
+        }
+
+    public:
+        // TLockFreeStack<TEvent*> Stack;
+        // std::atomic<i32> StackSize;
+        // //std::deque<TEvent*> Stack;
+
+        // static constexpr i32 MAX_STACK_SIZE = 10;
+
+        TEvent* New() {
+            // TEvent* result;
+            // if (Stack.Dequeue(&result)) {
+            //     --StackSize;
+            //     return result;
+            // }
+            // /*if (!Stack.empty()) {
+            //     TEvent* result = Stack.back();
+            //     Stack.pop_back();
+            //     return result;
+            // }*/
+            return new TEvent();
+        }
+
+        void Delete(TEvent* event) {
+            // if (StackSize < MAX_STACK_SIZE) {
+            //     Stack.Enqueue(event);
+            //     ++StackSize;
+            // } else {
+            //     delete event;
+            // }
+            // /*if (Stack.size() < MAX_STACK_SIZE) {
+            //     event->Record.Clear();
+            //     Stack.push_back(event);
+            //     return;
+            // }*/
+            delete event;
+        }
+
+        virtual IEventHandle* Construct(const TEventMeta& eventMeta) override {
+            IEventHandle* ev = nullptr;
+            if (eventMeta.Type == TEvent::EventType) {
+                TEvent* event = New();
+                DeserializeProtoEvent(event, eventMeta);
+            }
+            return ev;
+        }
+
+        virtual void Destruct(IEventHandle* ev) override {
+            if (ev->Type != TEvent::EventType) {
+                Y_FAIL("Wrong event supplied");
+            }
+            Delete(static_cast<TEvent*>(ev));
+        }
+
+        TLightEventFactory() {
+            Cerr << "TLightEventFactory<" << TypeName<TEvent>() << ">()" << Endl;
+            TLightEventSpaceFactories<GetEventSpace(TEvent::EventType)>::SetEventFactory(TEvent::EventType, this);
+        }
+    };
+
+    template<typename TEv>
+    struct TLightEventFactoryInitializer {
+        static TLightEventFactory<TEv> EventFactory;
+
+        static TEv* New() {
+            return EventFactory.New();
+        }
+
+        static void Delete(TEv* event) {
+            EventFactory.Delete(event);
+        }
+    };
+
+    template<typename TEv>
+    TLightEventFactory<TEv> TLightEventFactoryInitializer<TEv>::EventFactory;
+
+    template<typename TEv, typename TRecord, ui32 EventType0>
+    class TEventLightPB : public IEventHandleLightSerializable, public TLightEventFactoryInitializer<TEv> {
+    public:
+        static constexpr ui32 EventType = EventType0;
+
+        TRecord Record;
+
+        static bool SerializeProto(const IEventHandleLightSerializable* event, TChunkSerializer* chunker) {
+            return TLightEventFactory<TEv>::SerializeProtoEvent(static_cast<const TEv*>(event), chunker);
+        }
+
+        TEventLightPB()
+            : IEventHandleLightSerializable(EventType, &TEventLightPB<TEv, TRecord, EventType0>::SerializeProto)
+        {}
+
+        TEv* Get() {
+            return static_cast<TEv*>(this);
+        }
+
+        using TPtr = TAutoPtr<TEv>;
+    };
+
+    template<typename TEv, typename TRecord, ui32 EventType0>
+    class TEventLightPBWithPayload : public TEventLightPB<TEv, TRecord, EventType0> {
+    public:
+        std::vector<TRope> Payload;
+    };
 }
diff --git a/library/cpp/actors/core/events_undelivered.cpp b/library/cpp/actors/core/events_undelivered.cpp
index dfd79bf96e9..ea5fd101243 100644
--- a/library/cpp/actors/core/events_undelivered.cpp
+++ b/library/cpp/actors/core/events_undelivered.cpp
@@ -38,23 +38,70 @@ namespace NActors {
         return new TEvUndelivered(sourceType, reason);
     }
 
-    TAutoPtr<IEventHandle> IEventHandle::ForwardOnNondelivery(ui32 reason, bool unsure) {
-        if (Flags & FlagForwardOnNondelivery) {
-            const ui32 updatedFlags = Flags & ~(FlagForwardOnNondelivery | FlagSubscribeOnSession);
-            const TActorId recp = OnNondeliveryHolder ? OnNondeliveryHolder->Recipient : TActorId();
+    TAutoPtr<IEventHandle> IEventHandle::ForwardOnNondelivery(TAutoPtr<IEventHandle>& ev, ui32 reason, bool unsure) {
+        std::unique_ptr<IEventHandle> tev(ev.Release());
+        TAutoPtr<IEventHandle> fw = ForwardOnNondelivery(tev, reason, unsure);
+        if (tev) {
+            // we don't want to delete original event handle here
+            ev = tev.release();
+        }
+        return fw;
+    }
+
+    TAutoPtr<IEventHandle> IEventHandle::ForwardOnNondelivery(std::unique_ptr<IEventHandle>& ev, ui32 reason, bool unsure) {
+        if (ev->IsEventFat()) {
+            std::unique_ptr<IEventHandleFat> evf(IEventHandleFat::GetFat(ev.release()));
+            std::unique_ptr<IEventHandle> fw = IEventHandleFat::ForwardOnNondelivery(evf, reason, unsure);
+            if (evf) {
+                ev = std::unique_ptr<IEventHandle>(evf.release());
+            }
+            return fw.release();
+        }
+        if (ev->IsEventLight()) {
+            std::unique_ptr<IEventHandleLight> evl(IEventHandleLight::GetLight(ev.release()));
+            std::unique_ptr<IEventHandle> fw = IEventHandleLight::ForwardOnNondelivery(evl, reason, unsure);
+            if (evl) {
+                ev = std::unique_ptr<IEventHandle>(evl.release());
+            }
+            return fw.release();
+        }
+        return {};
+    }
 
-            if (Event)
-                return new IEventHandle(recp, Sender, Event.Release(), updatedFlags, Cookie, &Recipient, std::move(TraceId));
+    std::unique_ptr<IEventHandle> IEventHandleFat::ForwardOnNondelivery(std::unique_ptr<IEventHandleFat>& ev, ui32 reason, bool unsure) {
+        if (ev->ForwardOnNondeliveryFlag) {
+            const ui32 updatedFlags = ev->Flags & ~(FlagForwardOnNondelivery | FlagSubscribeOnSession);
+            const TActorId recp = ev->OnNondeliveryHolder ? ev->OnNondeliveryHolder->Recipient : TActorId();
+
+            if (ev->Event)
+                return std::unique_ptr<IEventHandle>(new IEventHandleFat(recp, ev->Sender, ev->Event.Release(), updatedFlags, ev->Cookie, &ev->Recipient, std::move(ev->TraceId)));
             else
-                return new IEventHandle(Type, updatedFlags, recp, Sender, Buffer, Cookie, &Recipient, std::move(TraceId));
+                return std::unique_ptr<IEventHandle>(new IEventHandleFat(ev->Type, updatedFlags, recp, ev->Sender, ev->Buffer, ev->Cookie, &ev->Recipient, std::move(ev->TraceId)));
         }
 
-        if (Flags & FlagTrackDelivery) {
-            const ui32 updatedFlags = Flags & ~(FlagTrackDelivery | FlagSubscribeOnSession | FlagGenerateUnsureUndelivered);
-            return new IEventHandle(Sender, Recipient, new TEvents::TEvUndelivered(Type, reason, unsure), updatedFlags,
-                Cookie, nullptr, std::move(TraceId));
+        if (ev->TrackDelivery) {
+            const ui32 updatedFlags = ev->Flags & ~(FlagTrackDelivery | FlagSubscribeOnSession | FlagGenerateUnsureUndelivered);
+            return std::unique_ptr<IEventHandle>(new IEventHandleFat(ev->Sender, ev->Recipient, new TEvents::TEvUndelivered(ev->Type, reason, unsure), updatedFlags,
+                ev->Cookie, nullptr, std::move(ev->TraceId)));
         }
+        return {};
+    }
 
-        return nullptr;
+    std::unique_ptr<IEventHandle> IEventHandleLight::ForwardOnNondelivery(std::unique_ptr<IEventHandleLight>& ev, ui32 reason, bool unsure) {
+        if (ev->ForwardOnNondeliveryFlag) {
+            ev->ForwardOnNondeliveryFlag = false;
+            ev->SubscribeOnSession = false;
+            auto recpt = ev->Recipient;
+            ev->Recipient = ev->OnNondeliveryHolder ? ev->OnNondeliveryHolder->Recipient : TActorId();
+            ev->OnNondeliveryHolder = MakeHolder<TOnNondelivery>(recpt);
+            return std::unique_ptr<IEventHandle>(ev.release());
+        }
+
+        if (ev->TrackDelivery) {
+            const ui32 updatedFlags = ev->Flags & ~(FlagTrackDelivery | FlagSubscribeOnSession | FlagGenerateUnsureUndelivered);
+            return std::unique_ptr<IEventHandle>(new IEventHandleFat(ev->Sender, ev->Recipient, new TEvents::TEvUndelivered(ev->Type, reason, unsure), updatedFlags,
+                ev->Cookie, nullptr, std::move(ev->TraceId)));
+        }
+        return {};
     }
 }
diff --git a/library/cpp/actors/core/executor_thread.cpp b/library/cpp/actors/core/executor_thread.cpp
index 3c5dc2c2b4d..50ae097a15c 100644
--- a/library/cpp/actors/core/executor_thread.cpp
+++ b/library/cpp/actors/core/executor_thread.cpp
@@ -96,13 +96,12 @@ namespace NActors {
 
     inline void LwTraceSlowDelivery(IEventHandle* ev, const std::type_info* actorType, ui32 poolId, const TActorId& currentRecipient,
                                     double delivMs, double sinceActivationMs, ui32 eventsExecutedBefore) {
-        const auto baseEv = (ev && ev->HasEvent()) ? ev->GetBase() : nullptr;
         LWPROBE(EventSlowDelivery,
                 poolId,
                 delivMs,
                 sinceActivationMs,
                 eventsExecutedBefore,
-                baseEv ? SafeTypeName(baseEv) : (ev ? ToString(ev->Type) : TString("nullptr")),
+                ev && ev->HasEvent() ? ev->GetTypeName() : (ev ? ToString(ev->Type) : TString("nullptr")),
                 currentRecipient.ToString(),
                 SafeTypeName(actorType));
     }
@@ -110,11 +109,10 @@ namespace NActors {
     inline void LwTraceSlowEvent(IEventHandle* ev, ui32 evTypeForTracing, const std::type_info* actorType, ui32 poolId,
                                  const TActorId& currentRecipient, double eventMs) {
         // Event could have been destroyed by actor->Receive();
-        const auto baseEv = (ev && ev->HasEvent()) ? ev->GetBase() : nullptr;
         LWPROBE(SlowEvent,
                 poolId,
                 eventMs,
-                baseEv ? SafeTypeName(baseEv) : ToString(evTypeForTracing),
+                ev && ev->HasEvent() ? ev->GetTypeName() : ToString(evTypeForTracing),
                 currentRecipient.ToString(),
                 SafeTypeName(actorType));
     }
@@ -178,7 +176,7 @@ namespace NActors {
                         NProfiling::TMemoryTagScope::Reset(ActorSystem->MemProfActivityBase + activityType);
                     }
 
-                    actor->Receive(ev, ctx);
+                    actor->Receive(ev);
 
                     size_t dyingActorsCnt = DyingActors.size();
                     Ctx.UpdateActorsStats(dyingActorsCnt);
@@ -204,7 +202,7 @@ namespace NActors {
                 } else {
                     actorType = nullptr;
 
-                    TAutoPtr<IEventHandle> nonDelivered = ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown);
+                    TAutoPtr<IEventHandle> nonDelivered = IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown);
                     if (nonDelivered.Get()) {
                         ActorSystem->Send(nonDelivered);
                     } else {
diff --git a/library/cpp/actors/core/io_dispatcher.cpp b/library/cpp/actors/core/io_dispatcher.cpp
index 6bd753f2e04..cccb2336ffc 100644
--- a/library/cpp/actors/core/io_dispatcher.cpp
+++ b/library/cpp/actors/core/io_dispatcher.cpp
@@ -116,7 +116,7 @@ namespace NActors {
                     bool sendNotify;
                     if (!Actor.TaskQueue.Dequeue(tasks, &sendNotify)) {
                         if (sendNotify) {
-                            ActorSystem->Send(new IEventHandle(EvNotifyThreadStopped, 0, Actor.SelfId(), TActorId(),
+                            ActorSystem->Send(new IEventHandleFat(EvNotifyThreadStopped, 0, Actor.SelfId(), TActorId(),
                                 nullptr, TThread::CurrentThreadId()));
                         }
                         break;
diff --git a/library/cpp/actors/core/io_dispatcher.h b/library/cpp/actors/core/io_dispatcher.h
index b0e4e60d1a7..a33cb0d98e6 100644
--- a/library/cpp/actors/core/io_dispatcher.h
+++ b/library/cpp/actors/core/io_dispatcher.h
@@ -28,7 +28,7 @@ namespace NActors {
      */
     template<typename TCallback>
     static void InvokeIoCallback(TCallback&& callback, ui32 poolId, IActor::EActivityType activityType) {
-        if (!TActivationContext::Send(new IEventHandle(MakeIoDispatcherActorId(), TActorId(),
+        if (!TActivationContext::Send(new IEventHandleFat(MakeIoDispatcherActorId(), TActorId(),
                 new TEvInvokeQuery(callback)))) {
             TActivationContext::Register(CreateExecuteLaterActor(std::move(callback), activityType), TActorId(),
                 TMailboxType::HTSwap, poolId);
diff --git a/library/cpp/actors/core/log.h b/library/cpp/actors/core/log.h
index 5000216f50c..c7bed09f1ba 100644
--- a/library/cpp/actors/core/log.h
+++ b/library/cpp/actors/core/log.h
@@ -116,7 +116,7 @@
     const auto& currentTracer = component;                                                                                             \
     if (ev->HasEvent()) {                                                                                                              \
         LOG_TRACE(*TlsActivationContext, currentTracer, "%s, received event# %" PRIu32 ", Sender %s, Recipient %s: %s",                                  \
-                  __FUNCTION__, ev->Type, ev->Sender.ToString().data(), SelfId().ToString().data(), ev->GetBase()->ToString().substr(0, 1000).data()); \
+                  __FUNCTION__, ev->Type, ev->Sender.ToString().data(), SelfId().ToString().data(), ev->ToString().substr(0, 1000).data()); \
     } else {                                                                                                                           \
         LOG_TRACE(*TlsActivationContext, currentTracer, "%s, received event# %" PRIu32 ", Sender %s, Recipient %s",                                      \
                   __FUNCTION__, ev->Type, ev->Sender.ToString().data(), ev->Recipient.ToString().data());                                          \
@@ -205,7 +205,7 @@ namespace NActors {
                      std::shared_ptr<NMonitoring::TMetricRegistry> metrics);
         ~TLoggerActor();
 
-        void StateFunc(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) { 
+        void StateFunc(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
             switch (ev->GetTypeRewrite()) {
                 HFunc(TFlushLogBuffer, FlushLogBufferMessageEvent);
                 HFunc(NLog::TEvLog, HandleLogEvent);
@@ -316,7 +316,7 @@ namespace NActors {
     {
         const NLog::TSettings *mSettings = ctx.LoggerSettings();
         TLoggerActor::Throttle(*mSettings);
-        ctx.Send(new IEventHandle(mSettings->LoggerActorId, TActorId(), new NLog::TEvLog(mPriority, mComponent, std::move(str))));
+        ctx.Send(new IEventHandleFat(mSettings->LoggerActorId, TActorId(), new NLog::TEvLog(mPriority, mComponent, std::move(str))));
     }
 
     template <typename TCtx, typename... TArgs>
diff --git a/library/cpp/actors/core/log_ut.cpp b/library/cpp/actors/core/log_ut.cpp
index 995e3c4121c..572af788ec9 100644
--- a/library/cpp/actors/core/log_ut.cpp
+++ b/library/cpp/actors/core/log_ut.cpp
@@ -105,19 +105,19 @@ namespace {
         {}
 
         void WriteLog() {
-            Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvLog(TInstant::Zero(), TLevel{EPrio::Emerg}, 0, "foo")});
+            Runtime.Send(new IEventHandleFat{LoggerActor, {}, new TEvLog(TInstant::Zero(), TLevel{EPrio::Emerg}, 0, "foo")});
         }
 
         void WriteLog(TInstant ts, EPrio prio = EPrio::Emerg, TString msg = "foo") {
-            Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvLog(ts, TLevel{prio}, 0, msg)});
+            Runtime.Send(new IEventHandleFat{LoggerActor, {}, new TEvLog(ts, TLevel{prio}, 0, msg)});
         }
 
         void FlushLogBuffer() {
-            Runtime.Send(new IEventHandle{LoggerActor, {}, new TFlushLogBuffer()});
+            Runtime.Send(new IEventHandleFat{LoggerActor, {}, new TFlushLogBuffer()});
         }
 
         void Wakeup() {
-            Runtime.Send(new IEventHandle{LoggerActor, {}, new TEvents::TEvWakeup});
+            Runtime.Send(new IEventHandleFat{LoggerActor, {}, new TEvents::TEvWakeup});
         }
 
         TIntrusivePtr<TDynamicCounters> Counters{MakeIntrusive<TDynamicCounters>()};
diff --git a/library/cpp/actors/core/scheduler_actor.cpp b/library/cpp/actors/core/scheduler_actor.cpp
index febc5e40dd2..fef051da619 100644
--- a/library/cpp/actors/core/scheduler_actor.cpp
+++ b/library/cpp/actors/core/scheduler_actor.cpp
@@ -234,7 +234,7 @@ namespace NActors {
                     sentCount = Min(eventsToBeSentSize, Cfg.RelaxedSendPaceEventsPerCycle);
                 }
                 for (ui32 i = 0; i < sentCount; ++i) {
-                    ctx.Send(EventsToBeSent.front());
+                    ctx.Send(EventsToBeSent.front().Release());
                     EventsToBeSent.pop_front();
                 }
 
diff --git a/library/cpp/actors/dnsresolver/dnsresolver.cpp b/library/cpp/actors/dnsresolver/dnsresolver.cpp
index 71e7f4d037f..396194b266a 100644
--- a/library/cpp/actors/dnsresolver/dnsresolver.cpp
+++ b/library/cpp/actors/dnsresolver/dnsresolver.cpp
@@ -328,7 +328,7 @@ namespace NDnsResolver {
                     }
                     result->Status = status;
 
-                    reqCtx->ActorSystem->Send(new IEventHandle(reqCtx->Sender, reqCtx->SelfId, result.Release(), 0, reqCtx->Cookie));
+                    reqCtx->ActorSystem->Send(new IEventHandleFat(reqCtx->Sender, reqCtx->SelfId, result.Release(), 0, reqCtx->Cookie));
                     break;
                 }
 
@@ -356,7 +356,7 @@ namespace NDnsResolver {
                     }
                     result->Status = status;
 
-                    reqCtx->ActorSystem->Send(new IEventHandle(reqCtx->Sender, reqCtx->SelfId, result.Release(), 0, reqCtx->Cookie));
+                    reqCtx->ActorSystem->Send(new IEventHandleFat(reqCtx->Sender, reqCtx->SelfId, result.Release(), 0, reqCtx->Cookie));
                     break;
                 }
             }
diff --git a/library/cpp/actors/dnsresolver/dnsresolver_caching_ut.cpp b/library/cpp/actors/dnsresolver/dnsresolver_caching_ut.cpp
index 89a7e9ab368..5f9fd3c4447 100644
--- a/library/cpp/actors/dnsresolver/dnsresolver_caching_ut.cpp
+++ b/library/cpp/actors/dnsresolver/dnsresolver_caching_ut.cpp
@@ -256,7 +256,7 @@ Y_UNIT_TEST_SUITE(CachingDnsResolver) {
         }
 
         void Sleep(TDuration duration) {
-            Schedule(new IEventHandle(Sleeper, Sleeper, new TEvents::TEvWakeup), duration);
+            Schedule(new IEventHandleFat(Sleeper, Sleeper, new TEvents::TEvWakeup), duration);
             GrabEdgeEventRethrow<TEvents::TEvWakeup>(Sleeper);
         }
 
@@ -272,11 +272,11 @@ Y_UNIT_TEST_SUITE(CachingDnsResolver) {
         }
 
         void SendGetHostByName(const TActorId& sender, const TString& name, int family = AF_UNSPEC) {
-            Send(new IEventHandle(Resolver, sender, new TEvDns::TEvGetHostByName(name, family)), 0, true);
+            Send(new IEventHandleFat(Resolver, sender, new TEvDns::TEvGetHostByName(name, family)), 0, true);
         }
 
         void SendGetAddr(const TActorId& sender, const TString& name, int family = AF_UNSPEC) {
-            Send(new IEventHandle(Resolver, sender, new TEvDns::TEvGetAddr(name, family)), 0, true);
+            Send(new IEventHandleFat(Resolver, sender, new TEvDns::TEvGetAddr(name, family)), 0, true);
         }
 
         TEvDns::TEvGetHostByNameResult::TPtr WaitGetHostByName(const TActorId& sender) {
@@ -387,7 +387,7 @@ Y_UNIT_TEST_SUITE(CachingDnsResolver) {
         runtime.SendGetAddr(sender, "yandex.ru", AF_UNSPEC);
         runtime.ExpectGetAddrSuccess(sender, "2a02:6b8:a::a");
 
-        runtime.Send(new IEventHandle(runtime.MockResolver, { }, new TEvents::TEvPoison), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.MockResolver, { }, new TEvents::TEvPoison), 0, true);
         runtime.SendGetAddr(sender, "foo.ru", AF_UNSPEC);
         runtime.ExpectGetAddrError(sender, ARES_ENOTINITIALIZED);
     }
@@ -640,7 +640,7 @@ Y_UNIT_TEST_SUITE(CachingDnsResolver) {
 
         runtime.SendGetHostByName(sender, "yandex.ru", AF_UNSPEC);
         runtime.SendGetAddr(sender, "yandex.ru", AF_UNSPEC);
-        runtime.Send(new IEventHandle(runtime.Resolver, sender, new TEvents::TEvPoison), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.Resolver, sender, new TEvents::TEvPoison), 0, true);
         runtime.ExpectGetHostByNameError(sender, ARES_ECANCELLED);
         runtime.ExpectGetAddrError(sender, ARES_ECANCELLED);
     }
diff --git a/library/cpp/actors/dnsresolver/dnsresolver_ondemand.cpp b/library/cpp/actors/dnsresolver/dnsresolver_ondemand.cpp
index 2025162e951..f55251e2809 100644
--- a/library/cpp/actors/dnsresolver/dnsresolver_ondemand.cpp
+++ b/library/cpp/actors/dnsresolver/dnsresolver_ondemand.cpp
@@ -25,7 +25,7 @@ namespace NDnsResolver {
 
         void Forward(STATEFN_SIG) {
             ev->Rewrite(ev->GetTypeRewrite(), GetUpstream());
-            TActivationContext::Send(std::move(ev));
+            TActivationContext::Send(ev.Release());
         }
 
     private:
diff --git a/library/cpp/actors/dnsresolver/dnsresolver_ondemand_ut.cpp b/library/cpp/actors/dnsresolver/dnsresolver_ondemand_ut.cpp
index 27584845524..d15fd541928 100644
--- a/library/cpp/actors/dnsresolver/dnsresolver_ondemand_ut.cpp
+++ b/library/cpp/actors/dnsresolver/dnsresolver_ondemand_ut.cpp
@@ -13,7 +13,7 @@ Y_UNIT_TEST_SUITE(OnDemandDnsResolver) {
         runtime.Initialize();
         auto sender = runtime.AllocateEdgeActor();
         auto resolver = runtime.Register(CreateOnDemandDnsResolver());
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("localhost", AF_UNSPEC)),
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvDns::TEvGetHostByName("localhost", AF_UNSPEC)),
                 0, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
diff --git a/library/cpp/actors/dnsresolver/dnsresolver_ut.cpp b/library/cpp/actors/dnsresolver/dnsresolver_ut.cpp
index 0c343a805ce..089bd5179f2 100644
--- a/library/cpp/actors/dnsresolver/dnsresolver_ut.cpp
+++ b/library/cpp/actors/dnsresolver/dnsresolver_ut.cpp
@@ -28,7 +28,7 @@ Y_UNIT_TEST_SUITE(DnsResolver) {
         runtime.Initialize();
         auto sender = runtime.AllocateEdgeActor();
         auto resolver = runtime.Register(CreateSimpleDnsResolver());
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("localhost", AF_UNSPEC)),
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvDns::TEvGetHostByName("localhost", AF_UNSPEC)),
                 0, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
@@ -41,7 +41,7 @@ Y_UNIT_TEST_SUITE(DnsResolver) {
         runtime.Initialize();
         auto sender = runtime.AllocateEdgeActor();
         auto resolver = runtime.Register(CreateSimpleDnsResolver());
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("yandex.ru", AF_UNSPEC)),
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvDns::TEvGetHostByName("yandex.ru", AF_UNSPEC)),
                 0, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
@@ -55,7 +55,7 @@ Y_UNIT_TEST_SUITE(DnsResolver) {
         auto sender = runtime.AllocateEdgeActor();
         auto resolver = runtime.Register(CreateSimpleDnsResolver());
 
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetAddr("yandex.ru", AF_UNSPEC)),
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvDns::TEvGetAddr("yandex.ru", AF_UNSPEC)),
                 0, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetAddrResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
@@ -72,7 +72,7 @@ Y_UNIT_TEST_SUITE(DnsResolver) {
         options.Attempts = 2;
         options.Servers.emplace_back(TStringBuilder() << "127.0.0.1:" << server.Port);
         auto resolver = runtime.Register(CreateSimpleDnsResolver(options));
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("timeout.yandex.ru", AF_INET)),
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvDns::TEvGetHostByName("timeout.yandex.ru", AF_INET)),
                 0, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, ARES_ETIMEOUT, ev->Get()->ErrorText);
@@ -88,9 +88,9 @@ Y_UNIT_TEST_SUITE(DnsResolver) {
         options.Attempts = 5;
         options.Servers.emplace_back(TStringBuilder() << "127.0.0.1:" << server.Port);
         auto resolver = runtime.Register(CreateSimpleDnsResolver(options));
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("timeout.yandex.ru", AF_INET)),
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvDns::TEvGetHostByName("timeout.yandex.ru", AF_INET)),
                 0, true);
-        runtime.Send(new IEventHandle(resolver, sender, new TEvents::TEvPoison), 0, true);
+        runtime.Send(new IEventHandleFat(resolver, sender, new TEvents::TEvPoison), 0, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, ARES_ECANCELLED, ev->Get()->ErrorText);
     }
diff --git a/library/cpp/actors/helpers/flow_controlled_queue.cpp b/library/cpp/actors/helpers/flow_controlled_queue.cpp
index 41e0944c628..4f67f85a3ba 100644
--- a/library/cpp/actors/helpers/flow_controlled_queue.cpp
+++ b/library/cpp/actors/helpers/flow_controlled_queue.cpp
@@ -102,7 +102,7 @@ class TFlowControlledRequestQueue : public IActorCallback {
             Subscribed = true;
         }
 
-        TActivationContext::Send(new IEventHandle(Target, reqActorId, ev->ReleaseBase().Release(), IEventHandle::FlagTrackDelivery, ev->Cookie));
+        TActivationContext::Send(new IEventHandleFat(Target, reqActorId, IEventHandleFat::GetFat(ev.Get())->ReleaseBase().Release(), IEventHandle::FlagTrackDelivery, ev->Cookie));
     }
 
     void PumpQueue() {
@@ -123,7 +123,7 @@ class TFlowControlledRequestQueue : public IActorCallback {
             if (reqActor) {
                 if (reqActor->Flags & IEventHandle::FlagSubscribeOnSession) {
                     TActivationContext::Send(
-                        new IEventHandle(reqActor->Source, TActorId(), new TEvInterconnect::TEvNodeDisconnected(nodeid), 0, reqActor->Cookie)
+                        new IEventHandleFat(reqActor->Source, TActorId(), new TEvInterconnect::TEvNodeDisconnected(nodeid), 0, reqActor->Cookie)
                     );
                 }
                 reqActor->PassAway();
@@ -136,7 +136,7 @@ class TFlowControlledRequestQueue : public IActorCallback {
             const auto reason = TEvents::TEvUndelivered::Disconnected;
             if (ev->Flags & IEventHandle::FlagTrackDelivery) {
                 TActivationContext::Send(
-                    new IEventHandle(ev->Sender, ev->Recipient, new TEvents::TEvUndelivered(ev->GetTypeRewrite(), reason), 0, ev->Cookie)
+                    new IEventHandleFat(ev->Sender, ev->Recipient, new TEvents::TEvUndelivered(ev->GetTypeRewrite(), reason), 0, ev->Cookie)
                 );
             }
         }
@@ -175,8 +175,8 @@ public:
         auto it = Find(RegisteredRequests, reqActor);
         if (it == RegisteredRequests.end())
             return;
-
-        TActivationContext::Send(ev->Forward(reqActor->Source));
+        IEventHandle::Forward(ev, reqActor->Source);
+        TActivationContext::Send(ev);
         const TDuration reqLatency = reqActor->AccumulatedLatency();
         if (reqLatency < MinimalSeenLatency)
             MinimalSeenLatency = reqLatency;
@@ -190,7 +190,7 @@ public:
         if (it == RegisteredRequests.end())
             return;
 
-        TActivationContext::Send(ev->Forward(reqActor->Source));
+        TActivationContext::Send(ev->Forward(reqActor->Source).Release());
 
         *it = nullptr;
         PumpQueue();
diff --git a/library/cpp/actors/helpers/future_callback.h b/library/cpp/actors/helpers/future_callback.h
index 8ca0d99fdae..4db11c73132 100644
--- a/library/cpp/actors/helpers/future_callback.h
+++ b/library/cpp/actors/helpers/future_callback.h
@@ -7,7 +7,7 @@ namespace NActors {
 
 template <typename EventType>
 struct TActorFutureCallback : TActor<TActorFutureCallback<EventType>> {
-    using TCallback = std::function<void(TAutoPtr<TEventHandle<EventType>>&)>;
+    using TCallback = std::function<void(TAutoPtr<TEventHandleFat<EventType>>&)>;
     using TBase = TActor<TActorFutureCallback<EventType>>;
     TCallback Callback;
 
@@ -30,4 +30,29 @@ struct TActorFutureCallback : TActor<TActorFutureCallback<EventType>> {
     }
 };
 
+template <typename EventType>
+struct TActorFutureCallbackLight : TActor<TActorFutureCallbackLight<EventType>> {
+    using TCallback = std::function<void(TAutoPtr<EventType>&)>;
+    using TBase = TActor<TActorFutureCallbackLight<EventType>>;
+    TCallback Callback;
+
+    static constexpr IActor::EActivityType ActorActivityType() {
+        return IActor::ACTOR_FUTURE_CALLBACK;
+    }
+
+    TActorFutureCallbackLight(TCallback&& callback)
+        : TBase(&TActorFutureCallbackLight::StateWaitForEvent)
+        , Callback(std::move(callback))
+    {}
+
+    STRICT_LIGHTFN(StateWaitForEvent,
+        hFunc(EventType, Handle)
+    )
+
+    void Handle(typename EventType::TPtr ev) {
+        Callback(ev);
+        TBase::PassAway();
+    }
+};
+
 } // NActors
diff --git a/library/cpp/actors/helpers/selfping_actor_ut.cpp b/library/cpp/actors/helpers/selfping_actor_ut.cpp
index 542f817755c..ed4c0972fb1 100644
--- a/library/cpp/actors/helpers/selfping_actor_ut.cpp
+++ b/library/cpp/actors/helpers/selfping_actor_ut.cpp
@@ -37,7 +37,7 @@ Y_UNIT_TEST_SUITE(TSelfPingTest) {
         const TActorId actorId = runtime->Register(actor);
         Y_UNUSED(actorId);
 
-        //runtime.Send(new IEventHandle(actorId, sender, new TEvSelfPing::TEvPing(0.0)));
+        //runtime.Send(new IEventHandleFat(actorId, sender, new TEvSelfPing::TEvPing(0.0)));
 
         // TODO check after events are handled
         //Sleep(TDuration::Seconds(1));
diff --git a/library/cpp/actors/http/http_proxy_incoming.cpp b/library/cpp/actors/http/http_proxy_incoming.cpp
index fa63783c2de..ddc3c670110 100644
--- a/library/cpp/actors/http/http_proxy_incoming.cpp
+++ b/library/cpp/actors/http/http_proxy_incoming.cpp
@@ -59,7 +59,7 @@ public:
     }
 
     TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parent) override {
-        return new IEventHandle(self, parent, new TEvents::TEvBootstrap());
+        return new IEventHandleFat(self, parent, new TEvents::TEvBootstrap());
     }
 
     void Die(const TActorContext& ctx) override {
diff --git a/library/cpp/actors/http/http_ut.cpp b/library/cpp/actors/http/http_ut.cpp
index e06de078677..7fbcb3f3d6c 100644
--- a/library/cpp/actors/http/http_ut.cpp
+++ b/library/cpp/actors/http/http_ut.cpp
@@ -303,22 +303,22 @@ Y_UNIT_TEST_SUITE(HttpProxy) {
 
         NActors::IActor* proxy = NHttp::CreateHttpProxy();
         NActors::TActorId proxyId = actorSystem.Register(proxy);
-        actorSystem.Send(new NActors::IEventHandle(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(port)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(port)), 0, true);
         actorSystem.DispatchEvents();
 
         NActors::TActorId serverId = actorSystem.AllocateEdgeActor();
-        actorSystem.Send(new NActors::IEventHandle(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
 
         NActors::TActorId clientId = actorSystem.AllocateEdgeActor();
         NHttp::THttpOutgoingRequestPtr httpRequest = NHttp::THttpOutgoingRequest::CreateRequestGet("http://127.0.0.1:" + ToString(port) + "/test");
-        actorSystem.Send(new NActors::IEventHandle(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingRequest* request = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingRequest>(handle);
 
         UNIT_ASSERT_EQUAL(request->Request->URL, "/test");
 
         NHttp::THttpOutgoingResponsePtr httpResponse = request->Request->CreateResponseString("HTTP/1.1 200 Found\r\nConnection: Close\r\nTransfer-Encoding: chunked\r\n\r\n6\r\npassed\r\n0\r\n\r\n");
-        actorSystem.Send(new NActors::IEventHandle(handle->Sender, serverId, new NHttp::TEvHttpProxy::TEvHttpOutgoingResponse(httpResponse)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(handle->Sender, serverId, new NHttp::TEvHttpProxy::TEvHttpOutgoingResponse(httpResponse)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingResponse* response = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingResponse>(handle);
 
@@ -336,22 +336,22 @@ Y_UNIT_TEST_SUITE(HttpProxy) {
 
         NActors::IActor* proxy = NHttp::CreateHttpProxy();
         NActors::TActorId proxyId = actorSystem.Register(proxy);
-        actorSystem.Send(new NActors::IEventHandle(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(port)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(port)), 0, true);
         actorSystem.DispatchEvents();
 
         NActors::TActorId serverId = actorSystem.AllocateEdgeActor();
-        actorSystem.Send(new NActors::IEventHandle(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
 
         NActors::TActorId clientId = actorSystem.AllocateEdgeActor();
         NHttp::THttpOutgoingRequestPtr httpRequest = NHttp::THttpOutgoingRequest::CreateRequestGet("http://[::1]:" + ToString(port) + "/test");
-        actorSystem.Send(new NActors::IEventHandle(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingRequest* request = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingRequest>(handle);
 
         UNIT_ASSERT_EQUAL(request->Request->URL, "/test");
 
         NHttp::THttpOutgoingResponsePtr httpResponse = request->Request->CreateResponseString("HTTP/1.1 200 Found\r\nConnection: Close\r\nTransfer-Encoding: chunked\r\n\r\n6\r\npassed\r\n0\r\n\r\n");
-        actorSystem.Send(new NActors::IEventHandle(handle->Sender, serverId, new NHttp::TEvHttpProxy::TEvHttpOutgoingResponse(httpResponse)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(handle->Sender, serverId, new NHttp::TEvHttpProxy::TEvHttpOutgoingResponse(httpResponse)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingResponse* response = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingResponse>(handle);
 
@@ -432,22 +432,22 @@ CRA/5XcX13GJwHHj6LCoc3sL7mt8qV9HKY2AOZ88mpObzISZxgPpdKCfjsrdm63V
         add->CertificateFile = certificateFile.Name();
         add->PrivateKeyFile = certificateFile.Name();
         /////////
-        actorSystem.Send(new NActors::IEventHandle(proxyId, TActorId(), add.Release()), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, TActorId(), add.Release()), 0, true);
         actorSystem.DispatchEvents();
 
         NActors::TActorId serverId = actorSystem.AllocateEdgeActor();
-        actorSystem.Send(new NActors::IEventHandle(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
 
         NActors::TActorId clientId = actorSystem.AllocateEdgeActor();
         NHttp::THttpOutgoingRequestPtr httpRequest = NHttp::THttpOutgoingRequest::CreateRequestGet("https://[::1]:" + ToString(port) + "/test");
-        actorSystem.Send(new NActors::IEventHandle(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingRequest* request = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingRequest>(handle);
 
         UNIT_ASSERT_EQUAL(request->Request->URL, "/test");
 
         NHttp::THttpOutgoingResponsePtr httpResponse = request->Request->CreateResponseString("HTTP/1.1 200 Found\r\nConnection: Close\r\nTransfer-Encoding: chunked\r\n\r\n6\r\npassed\r\n0\r\n\r\n");
-        actorSystem.Send(new NActors::IEventHandle(handle->Sender, serverId, new NHttp::TEvHttpProxy::TEvHttpOutgoingResponse(httpResponse)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(handle->Sender, serverId, new NHttp::TEvHttpProxy::TEvHttpOutgoingResponse(httpResponse)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingResponse* response = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingResponse>(handle);
 
@@ -487,11 +487,11 @@ CRA/5XcX13GJwHHj6LCoc3sL7mt8qV9HKY2AOZ88mpObzISZxgPpdKCfjsrdm63V
 
         NActors::IActor* proxy = NHttp::CreateHttpProxy();
         NActors::TActorId proxyId = actorSystem.Register(proxy);
-        actorSystem.Send(new NActors::IEventHandle(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(port)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(port)), 0, true);
         actorSystem.DispatchEvents();
 
         NActors::TActorId serverId = actorSystem.AllocateEdgeActor();
-        actorSystem.Send(new NActors::IEventHandle(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler("/test", serverId)), 0, true);
 
         NActors::TActorId clientId = actorSystem.AllocateEdgeActor();
         NHttp::THttpOutgoingRequestPtr httpRequest = NHttp::THttpOutgoingRequest::CreateRequestGet("http://[::1]:" + ToString(port) + "/test");
@@ -499,7 +499,7 @@ CRA/5XcX13GJwHHj6LCoc3sL7mt8qV9HKY2AOZ88mpObzISZxgPpdKCfjsrdm63V
         TString longHeader;
         longHeader.append(9000, 'X');
         httpRequest->Set(longHeader, "data");
-        actorSystem.Send(new NActors::IEventHandle(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
 
         NHttp::TEvHttpProxy::TEvHttpIncomingResponse* response = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingResponse>(handle);
 
diff --git a/library/cpp/actors/interconnect/event_filter.h b/library/cpp/actors/interconnect/event_filter.h
index 47dabf5f164..de3fdc2a04f 100644
--- a/library/cpp/actors/interconnect/event_filter.h
+++ b/library/cpp/actors/interconnect/event_filter.h
@@ -31,7 +31,7 @@ namespace NActors {
             evSpaceIndex[subtype] = routes;
         }
 
-        bool CheckIncomingEvent(const IEventHandle& ev, const TScopeId& localScopeId) const {
+        bool CheckIncomingEvent(const IEventHandleFat& ev, const TScopeId& localScopeId) const {
             TRouteMask routes = 0;
             if (const auto& evSpaceIndex = ScopeRoutes[ev.Type >> 16]) {
                 const ui16 subtype = ev.Type & 65535;
diff --git a/library/cpp/actors/interconnect/interconnect_channel.h b/library/cpp/actors/interconnect/interconnect_channel.h
index 312eff2666b..ce4adcdec23 100644
--- a/library/cpp/actors/interconnect/interconnect_channel.h
+++ b/library/cpp/actors/interconnect/interconnect_channel.h
@@ -59,10 +59,12 @@ namespace NActors {
             TEventHolder& event = Pool.Allocate(Queue);
             const ui32 bytes = event.Fill(ev) + (Params.UseExtendedTraceFmt ? sizeof(TEventDescr2) : sizeof(TEventDescr1));
             OutputQueueSize += bytes;
-            if (event.Span = NWilson::TSpan(15 /*max verbosity*/, NWilson::TTraceId(ev.TraceId), "Interconnect.Queue")) {
-                event.Span
-                    .Attribute("OutputQueueItems", static_cast<i64>(Queue.size()))
-                    .Attribute("OutputQueueSize", static_cast<i64>(OutputQueueSize));
+            if (ev.IsEventFat()) {
+                if (event.Span = NWilson::TSpan(15 /*max verbosity*/, NWilson::TTraceId(ev.TraceId), "Interconnect.Queue")) {
+                    event.Span
+                        .Attribute("OutputQueueItems", static_cast<i64>(Queue.size()))
+                        .Attribute("OutputQueueSize", static_cast<i64>(OutputQueueSize));
+                }
             }
             return std::make_pair(bytes, &event);
         }
diff --git a/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp b/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp
index a450d168719..e917a27ea74 100644
--- a/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp
+++ b/library/cpp/actors/interconnect/interconnect_proxy_wrapper.cpp
@@ -18,7 +18,7 @@ namespace NActors {
             , Mock(mock)
         {}
 
-        STFUNC(StateFunc) {
+        STATEFN(StateFunc) {
             if (ev->GetTypeRewrite() == TEvents::TSystem::Poison && !Proxy) {
                 PassAway();
             } else {
@@ -32,7 +32,7 @@ namespace NActors {
                     }
                     Y_VERIFY(Proxy);
                 }
-                InvokeOtherActor(*Proxy, &IActor::Receive, ev, ctx);
+                InvokeOtherActor(*Proxy, &IActor::Receive, ev);
             }
         }
     };
diff --git a/library/cpp/actors/interconnect/interconnect_resolve.cpp b/library/cpp/actors/interconnect/interconnect_resolve.cpp
index d638ff830cd..0b0b1126283 100644
--- a/library/cpp/actors/interconnect/interconnect_resolve.cpp
+++ b/library/cpp/actors/interconnect/interconnect_resolve.cpp
@@ -120,7 +120,7 @@ namespace NActors {
             LOG_DEBUG_IC("ICR03", "Host: %s, RESOLVED address", Host.c_str());
             auto reply = new TEvAddressInfo;
             reply->Address = std::move(addr);
-            TActivationContext::Send(new IEventHandle(ReplyTo, ReplyFrom, reply));
+            TActivationContext::Send(new IEventHandleFat(ReplyTo, ReplyFrom, reply));
             PassAway();
         }
 
@@ -129,7 +129,7 @@ namespace NActors {
             auto reply = std::make_unique<TEvLocalNodeInfo>();
             reply->NodeId = *NodeId;
             reply->Addresses = std::move(addresses);
-            TActivationContext::Send(new IEventHandle(ReplyTo, ReplyFrom, reply.release()));
+            TActivationContext::Send(new IEventHandleFat(ReplyTo, ReplyFrom, reply.release()));
             PassAway();
         }
 
@@ -138,7 +138,7 @@ namespace NActors {
             auto *event = new TEvResolveError;
             event->Explain = errorText;
             event->Host = Host;
-            TActivationContext::Send(new IEventHandle(ReplyTo, ReplyFrom, event));
+            TActivationContext::Send(new IEventHandleFat(ReplyTo, ReplyFrom, event));
             PassAway();
         }
 
diff --git a/library/cpp/actors/interconnect/interconnect_tcp_input_session.cpp b/library/cpp/actors/interconnect/interconnect_tcp_input_session.cpp
index b1212b89140..44abbb06bf4 100644
--- a/library/cpp/actors/interconnect/interconnect_tcp_input_session.cpp
+++ b/library/cpp/actors/interconnect/interconnect_tcp_input_session.cpp
@@ -330,7 +330,31 @@ namespace NActors {
         TEventSerializationInfo serializationInfo{
             .IsExtendedFormat = bool(descr.Flags & IEventHandle::FlagExtendedFormat),
         };
-        auto ev = std::make_unique<IEventHandle>(SessionId,
+        auto es = GetEventSpace(descr.Type);
+        if (es < TEventFactories::EventFactories.size() && TEventFactories::EventFactories[es] != nullptr) {
+            const auto& estvec(*TEventFactories::EventFactories[es]);
+            auto est = GetEventSubType(descr.Type);
+            if (est < estvec.size() && estvec[est] != nullptr) {
+                IEventFactory* factory = estvec[est];
+                TAutoPtr<IEventHandle> ev = factory->Construct({
+                    .Session = SessionId,
+                    .Type = descr.Type,
+                    .Flags = descr.Flags,
+                    .Recipient = descr.Recipient,
+                    .Sender = descr.Sender,
+                    .Cookie = descr.Cookie,
+                    .OriginScopeId = Params.PeerScopeId,
+                    .TraceId = std::move(descr.TraceId),
+                    .Data = std::move(data),
+                });
+                if (ev) {
+                    TActivationContext::Send(ev);
+                }
+                return;
+            }
+        }
+
+        auto ev = std::make_unique<IEventHandleFat>(SessionId,
             descr.Type,
             descr.Flags & ~IEventHandle::FlagExtendedFormat,
             descr.Recipient,
diff --git a/library/cpp/actors/interconnect/interconnect_tcp_proxy.cpp b/library/cpp/actors/interconnect/interconnect_tcp_proxy.cpp
index 3edded47d6a..8ee93dfc7a1 100644
--- a/library/cpp/actors/interconnect/interconnect_tcp_proxy.cpp
+++ b/library/cpp/actors/interconnect/interconnect_tcp_proxy.cpp
@@ -47,7 +47,7 @@ namespace NActors {
     void TInterconnectProxyTCP::Registered(TActorSystem* sys, const TActorId& owner) {
         if (!DynamicPtr) {
             // perform usual bootstrap for static nodes
-            sys->Send(new IEventHandle(TEvents::TSystem::Bootstrap, 0, SelfId(), owner, nullptr, 0));
+            sys->Send(new IEventHandleFat(TEvents::TSystem::Bootstrap, 0, SelfId(), owner, nullptr, 0));
         }
         if (const auto& mon = Common->RegisterMonPage) {
             TString path = Sprintf("peer%04" PRIu32, PeerNodeId);
@@ -509,7 +509,7 @@ namespace NActors {
                 if (ev->Flags & IEventHandle::FlagSubscribeOnSession) {
                     Send(ev->Sender, new TEvInterconnect::TEvNodeDisconnected(PeerNodeId), 0, ev->Cookie);
                 }
-                TActivationContext::Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected));
+                TActivationContext::Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected));
                 break;
 
             case TEvInterconnect::TEvConnectNode::EventType:
@@ -591,7 +591,7 @@ namespace NActors {
                 // we have found cancellation request for the pending handshake request; so simply remove it from the
                 // deque, as we are not interested in failure reason; must likely it happens because of handshake timeout
                 if (pendingEvent->GetTypeRewrite() == TEvHandshakeFail::EventType) {
-                    TEvHandshakeFail::TPtr tmp(static_cast<TEventHandle<TEvHandshakeFail>*>(pendingEvent.Release()));
+                    TEvHandshakeFail::TPtr tmp(static_cast<TEventHandleFat<TEvHandshakeFail>*>(pendingEvent.Release()));
                     LogHandshakeFail(tmp, true);
                 }
                 PendingIncomingHandshakeEvents.erase(it);
@@ -605,7 +605,7 @@ namespace NActors {
 
         Y_VERIFY(Session && SessionID);
         ValidateEvent(ev, "ForwardSessionEventToSession");
-        InvokeOtherActor(*Session, &TInterconnectSessionTCP::Receive, ev, TActivationContext::ActorContextFor(SessionID));
+        InvokeOtherActor(*Session, &TInterconnectSessionTCP::Receive, ev);
     }
 
     void TInterconnectProxyTCP::GenerateHttpInfo(NMon::TEvHttpInfo::TPtr& ev) {
@@ -774,7 +774,7 @@ namespace NActors {
         for (auto& ev : PendingIncomingHandshakeEvents) {
             Send(ev->Sender, new TEvents::TEvPoisonPill);
             if (ev->GetTypeRewrite() == TEvHandshakeFail::EventType) {
-                TEvHandshakeFail::TPtr tmp(static_cast<TEventHandle<TEvHandshakeFail>*>(ev.Release()));
+                TEvHandshakeFail::TPtr tmp(static_cast<TEventHandleFat<TEvHandshakeFail>*>(ev.Release()));
                 LogHandshakeFail(tmp, true);
             }
         }
diff --git a/library/cpp/actors/interconnect/interconnect_tcp_proxy.h b/library/cpp/actors/interconnect/interconnect_tcp_proxy.h
index 71edfccbe21..ebf02c3f274 100644
--- a/library/cpp/actors/interconnect/interconnect_tcp_proxy.h
+++ b/library/cpp/actors/interconnect/interconnect_tcp_proxy.h
@@ -63,10 +63,10 @@ namespace NActors {
 
         TInterconnectProxyTCP(const ui32 node, TInterconnectProxyCommon::TPtr common, IActor **dynamicPtr = nullptr);
 
-        STFUNC(StateInit) {
+        STATEFN(StateInit) {
             Bootstrap();
             if (ev->Type != TEvents::TSystem::Bootstrap) { // for dynamic nodes we do not receive Bootstrap event
-                Receive(ev, ctx);
+                Receive(ev);
             }
         }
 
@@ -180,7 +180,7 @@ namespace NActors {
             } else if (DynamicPtr) {
                 PassAwayTimestamp = TActivationContext::Monotonic() + TDuration::Seconds(15);
                 if (!PassAwayScheduled) {
-                    TActivationContext::Schedule(PassAwayTimestamp, new IEventHandle(EvPassAwayIfNeeded, 0, SelfId(),
+                    TActivationContext::Schedule(PassAwayTimestamp, new IEventHandleFat(EvPassAwayIfNeeded, 0, SelfId(),
                         {}, nullptr, 0));
                     PassAwayScheduled = true;
                 }
@@ -205,7 +205,7 @@ namespace NActors {
             if (now >= PassAwayTimestamp) {
                 PassAway();
             } else if (PassAwayTimestamp != TMonotonic::Max()) {
-                TActivationContext::Schedule(PassAwayTimestamp, new IEventHandle(EvPassAwayIfNeeded, 0, SelfId(),
+                TActivationContext::Schedule(PassAwayTimestamp, new IEventHandleFat(EvPassAwayIfNeeded, 0, SelfId(),
                     {}, nullptr, 0));
             } else {
                 PassAwayScheduled = false;
@@ -370,6 +370,21 @@ namespace NActors {
                 ev->Recipient.ToString().data(), ev->Type, PeerNodeId, func);
         }
 
+        void ValidateEvent(IEventHandle* ev, const char* func) {
+            if (SelfId().NodeId() == PeerNodeId) {
+                TString msg = Sprintf("Event Type# 0x%08" PRIx32 " TypeRewrite# 0x%08" PRIx32
+                    " from Sender# %s sent to the proxy for the node itself via Interconnect;"
+                    " THIS IS NOT A BUG IN INTERCONNECT, check the event sender instead",
+                    ev->Type, ev->GetTypeRewrite(), ev->Sender.ToString().data());
+                LOG_ERROR_IC("ICP03", "%s", msg.data());
+                Y_VERIFY_DEBUG(false, "%s", msg.data());
+            }
+
+            Y_VERIFY(ev->GetTypeRewrite() != TEvInterconnect::EvForward || ev->Recipient.NodeId() == PeerNodeId,
+                "Recipient/Proxy NodeId mismatch Recipient# %s Type# 0x%08" PRIx32 " PeerNodeId# %" PRIu32 " Func# %s",
+                ev->Recipient.ToString().data(), ev->Type, PeerNodeId, func);
+        }
+
         // Common with helpers
         // All proxy actors share the same information in the object
         // read only
diff --git a/library/cpp/actors/interconnect/interconnect_tcp_server.cpp b/library/cpp/actors/interconnect/interconnect_tcp_server.cpp
index aad8677ca46..316c233af3e 100644
--- a/library/cpp/actors/interconnect/interconnect_tcp_server.cpp
+++ b/library/cpp/actors/interconnect/interconnect_tcp_server.cpp
@@ -25,7 +25,7 @@ namespace NActors {
     }
 
     TAutoPtr<IEventHandle> TInterconnectListenerTCP::AfterRegister(const TActorId& self, const TActorId& parentId) {
-        return new IEventHandle(self, parentId, new TEvents::TEvBootstrap, 0);
+        return new IEventHandleFat(self, parentId, new TEvents::TEvBootstrap, 0);
     }
 
     void TInterconnectListenerTCP::Die(const TActorContext& ctx) {
diff --git a/library/cpp/actors/interconnect/interconnect_tcp_session.cpp b/library/cpp/actors/interconnect/interconnect_tcp_session.cpp
index dfc4d411d3b..3d6d18d274b 100644
--- a/library/cpp/actors/interconnect/interconnect_tcp_session.cpp
+++ b/library/cpp/actors/interconnect/interconnect_tcp_session.cpp
@@ -112,8 +112,8 @@ namespace NActors {
         Y_FAIL("TInterconnectSessionTCP::PassAway() can't be called directly");
     }
 
-    void TInterconnectSessionTCP::Forward(STATEFN_SIG) {
-        Proxy->ValidateEvent(ev, "Forward");
+    void TInterconnectSessionTCP::Forward(TAutoPtr<IEventHandle>& ev) {
+        Proxy->ValidateEvent(ev.Get(), "Forward");
 
         LOG_DEBUG_IC_SESSION("ICS02", "send event from: %s to: %s", ev->Sender.ToString().data(), ev->Recipient.ToString().data());
         ++MessagesGot;
@@ -126,7 +126,7 @@ namespace NActors {
         auto& oChannel = ChannelScheduler->GetOutputChannel(evChannel);
         const bool wasWorking = oChannel.IsWorking();
 
-        const auto [dataSize, event] = oChannel.Push(*ev);
+        const auto [dataSize, event] = oChannel.Push(*ev.Get());
         LWTRACK(ForwardEvent, event->Orbit, Proxy->PeerNodeId, event->Descr.Type, event->Descr.Flags, LWACTORID(event->Descr.Recipient), LWACTORID(event->Descr.Sender), event->Descr.Cookie, event->EventSerializedSize);
 
         TotalOutputQueueSize += dataSize;
@@ -167,7 +167,7 @@ namespace NActors {
         } else if (!RamInQueue) {
             Y_VERIFY_DEBUG(NumEventsInReadyChannels == 1);
             RamInQueue = new TEvRam(true);
-            auto *ev = new IEventHandle(SelfId(), {}, RamInQueue);
+            auto *ev = new IEventHandleFat(SelfId(), {}, RamInQueue);
             const TDuration batchPeriod = Proxy->Common->Settings.BatchPeriod;
             if (batchPeriod != TDuration()) {
                 TActivationContext::Schedule(batchPeriod, ev);
@@ -179,7 +179,7 @@ namespace NActors {
         }
     }
 
-    void TInterconnectSessionTCP::Subscribe(STATEFN_SIG) {
+    void TInterconnectSessionTCP::Subscribe(TAutoPtr<IEventHandle>& ev) {
         LOG_DEBUG_IC_SESSION("ICS04", "subscribe for session state for %s", ev->Sender.ToString().data());
         const auto [it, inserted] = Subscribers.emplace(ev->Sender, ev->Cookie);
         if (inserted) {
@@ -190,7 +190,7 @@ namespace NActors {
         Send(ev->Sender, new TEvInterconnect::TEvNodeConnected(Proxy->PeerNodeId), 0, ev->Cookie);
     }
 
-    void TInterconnectSessionTCP::Unsubscribe(STATEFN_SIG) {
+    void TInterconnectSessionTCP::Unsubscribe(TEvents::TEvUnsubscribe::TPtr ev) {
         LOG_DEBUG_IC_SESSION("ICS05", "unsubscribe for session state for %s", ev->Sender.ToString().data());
         Proxy->Metrics->SubSubscribersCount( Subscribers.erase(ev->Sender));
     }
diff --git a/library/cpp/actors/interconnect/interconnect_tcp_session.h b/library/cpp/actors/interconnect/interconnect_tcp_session.h
index 598a5c9220c..9d8bb90ecdc 100644
--- a/library/cpp/actors/interconnect/interconnect_tcp_session.h
+++ b/library/cpp/actors/interconnect/interconnect_tcp_session.h
@@ -347,16 +347,16 @@ namespace NActors {
         void Terminate(TDisconnectReason reason);
         void PassAway() override;
 
-        void Forward(STATEFN_SIG);
-        void Subscribe(STATEFN_SIG);
-        void Unsubscribe(STATEFN_SIG);
+        void Forward(LIGHTFN_SIG);
+        void Subscribe(TAutoPtr<IEventHandle>& ev);
+        void Unsubscribe(TEvents::TEvUnsubscribe::TPtr);
 
-        STRICT_STFUNC(StateFunc,
+        STRICT_LIGHTFN(StateFunc,
             fFunc(TEvInterconnect::EvForward, Forward)
             cFunc(TEvents::TEvPoisonPill::EventType, HandlePoison)
             fFunc(TEvInterconnect::TEvConnectNode::EventType, Subscribe)
             fFunc(TEvents::TEvSubscribe::EventType, Subscribe)
-            fFunc(TEvents::TEvUnsubscribe::EventType, Unsubscribe)
+            hFunc(TEvents::TEvUnsubscribe, Unsubscribe)
             cFunc(TEvFlush::EventType, HandleFlush)
             hFunc(TEvPollerReady, Handle)
             hFunc(TEvPollerRegisterResult, Handle)
@@ -531,7 +531,7 @@ namespace NActors {
             auto sender = SelfId();
             const auto eventFabric = [&sender](const TActorId& recp) -> IEventHandle* {
                 auto ev = new TEvSessionBufferSizeRequest();
-                return new IEventHandle(recp, sender, ev, IEventHandle::FlagTrackDelivery);
+                return new IEventHandleFat(recp, sender, ev, IEventHandle::FlagTrackDelivery);
             };
             RepliesNumber = TlsActivationContext->ExecutorThread.ActorSystem->BroadcastToProxies(eventFabric);
             Become(&TInterconnectSessionKiller::StateFunc);
diff --git a/library/cpp/actors/interconnect/load.cpp b/library/cpp/actors/interconnect/load.cpp
index d460903f35d..65e1d202ffb 100644
--- a/library/cpp/actors/interconnect/load.cpp
+++ b/library/cpp/actors/interconnect/load.cpp
@@ -82,7 +82,7 @@ namespace NInterconnect {
         )
 
         void Handle(TEvLoadMessage::TPtr& ev, const TActorContext& ctx) {
-            ctx.ExecutorThread.ActorSystem->Send(ev->Forward(Slaves[SlaveIndex]));
+            ctx.ExecutorThread.ActorSystem->Send(ev->Forward(Slaves[SlaveIndex]).Release());
             if (++SlaveIndex == Slaves.size()) {
                 SlaveIndex = 0;
             }
diff --git a/library/cpp/actors/interconnect/mock/ic_mock.cpp b/library/cpp/actors/interconnect/mock/ic_mock.cpp
index fb96a7f2ea2..5619f0f113d 100644
--- a/library/cpp/actors/interconnect/mock/ic_mock.cpp
+++ b/library/cpp/actors/interconnect/mock/ic_mock.cpp
@@ -60,11 +60,11 @@ namespace NActors {
                 TPeerInfo *peer = GetPeer(peerNodeId);
                 auto guard = TReadGuard(peer->Mutex);
                 if (peer->ActorSystem) {
-                    peer->ActorSystem->Send(new IEventHandle(peer->ProxyId, TActorId(), new TEvInject(std::move(messages),
+                    peer->ActorSystem->Send(new IEventHandleFat(peer->ProxyId, TActorId(), new TEvInject(std::move(messages),
                         originScopeId, senderSessionId)));
                 } else {
                     for (auto&& ev : messages) {
-                        TActivationContext::Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected));
+                        TActivationContext::Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected));
                     }
                 }
             }
@@ -78,7 +78,7 @@ namespace NActors {
                 TPeerInfo *peer = GetPeer(peerNodeId);
                 auto guard = TReadGuard(peer->Mutex);
                 if (peer->ActorSystem) {
-                    peer->ActorSystem->Send(new IEventHandle(EvCheckSession, 0, peer->ProxyId, {}, nullptr, 0));
+                    peer->ActorSystem->Send(new IEventHandleFat(EvCheckSession, 0, peer->ProxyId, {}, nullptr, 0));
                 }
             }
 
@@ -114,7 +114,7 @@ namespace NActors {
 
                 void Terminate() {
                     for (auto&& ev : std::exchange(Queue, {})) {
-                        TActivationContext::Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected));
+                        TActivationContext::Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected));
                     }
                     for (const auto& kv : Subscribers) {
                         Send(kv.first, new TEvInterconnect::TEvNodeDisconnected(Proxy->PeerNodeId), 0, kv.second);
@@ -130,7 +130,7 @@ namespace NActors {
                             Subscribe(ev->Sender, ev->Cookie);
                         }
                         if (Queue.empty()) {
-                            TActivationContext::Send(new IEventHandle(EvRam, 0, SelfId(), {}, {}, 0));
+                            TActivationContext::Send(new IEventHandleFat(EvRam, 0, SelfId(), {}, {}, 0));
                         }
                         Queue.emplace_back(ev.Release());
                     }
@@ -193,7 +193,7 @@ namespace NActors {
                 }
 
                 template <typename TEvent>
-                bool CheckNodeStatus(TAutoPtr<TEventHandle<TEvent>>& ev) {
+                bool CheckNodeStatus(TAutoPtr<TEventHandleFat<TEvent>>& ev) {
                     if (PeerNodeStatus != EPeerNodeStatus::EXISTS) {
                         std::unique_ptr<IEventHandle> tmp(ev.Release());
                         CheckNonexistentNode(tmp);
@@ -201,7 +201,7 @@ namespace NActors {
                     }
                     return true;
                 }
-                
+
                 bool CheckNodeStatus(TAutoPtr<IEventHandle>& ev) {
                     if (PeerNodeStatus != EPeerNodeStatus::EXISTS) {
                         std::unique_ptr<IEventHandle> tmp(ev.Release());
@@ -210,7 +210,7 @@ namespace NActors {
                     }
                     return true;
                 }
-                
+
                 void CheckNonexistentNode(std::unique_ptr<IEventHandle>& ev) {
                     if (PeerNodeStatus == EPeerNodeStatus::UNKNOWN) {
                         WaitingConnections.emplace_back(ev.release());
@@ -224,15 +224,15 @@ namespace NActors {
                                 if (ev->Flags & IEventHandle::FlagSubscribeOnSession) {
                                     Send(ev->Sender, new TEvInterconnect::TEvNodeDisconnected(Proxy->PeerNodeId), 0, ev->Cookie);
                                 }
-                                TActivationContext::Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected));
+                                TActivationContext::Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected));
                                 break;
-                                
-                            case TEvents::TEvSubscribe::EventType: 
+
+                            case TEvents::TEvSubscribe::EventType:
                             case TEvInterconnect::TEvConnectNode::EventType:
                                 Send(ev->Sender, new TEvInterconnect::TEvNodeDisconnected(Proxy->PeerNodeId), 0, ev->Cookie);
                                 break;
 
-                            case TEvents::TEvUnsubscribe::EventType: 
+                            case TEvents::TEvUnsubscribe::EventType:
                                 break;
 
                             default:
@@ -252,7 +252,7 @@ namespace NActors {
                     while (!WaitingConnections.empty()) {
                         TAutoPtr<IEventHandle> tmp(WaitingConnections.front().release());
                         WaitingConnections.pop_front();
-                        Receive(tmp, TActivationContext::AsActorContext());
+                        Receive(tmp);
                     }
                 }
             };
@@ -287,20 +287,28 @@ namespace NActors {
                     return; // drop messages from other sessions
                 }
                 if (auto *session = GetSession()) {
-                    for (auto&& ev : ev->Get()->Messages) {
-                        auto fw = std::make_unique<IEventHandle>(
-                            session->SelfId(),
-                            ev->Type,
-                            ev->Flags & ~IEventHandle::FlagForwardOnNondelivery,
-                            ev->Recipient,
-                            ev->Sender,
-                            ev->ReleaseChainBuffer(),
-                            ev->Cookie,
-                            msg->OriginScopeId,
-                            std::move(ev->TraceId)
-                        );
-                        if (!Common->EventFilter || Common->EventFilter->CheckIncomingEvent(*fw, Common->LocalScopeId)) {
-                            TActivationContext::Send(fw.release());
+                    for (auto&& evb : ev->Get()->Messages) {
+                        if (ev->IsEventLight()) {
+                            // TODO(xenoxeno):
+                            //if (!Common->EventFilter || Common->EventFilter->CheckIncomingEvent(*fw, Common->LocalScopeId)) {
+                                TActivationContext::Send(evb.release());
+                            //}
+                        } else {
+                            auto* ev = IEventHandleFat::GetFat(evb);
+                            auto fw = std::make_unique<IEventHandleFat>(
+                                session->SelfId(),
+                                ev->Type,
+                                ev->Flags & ~IEventHandle::FlagForwardOnNondelivery,
+                                ev->Recipient,
+                                ev->Sender,
+                                ev->ReleaseChainBuffer(),
+                                ev->Cookie,
+                                msg->OriginScopeId,
+                                std::move(ev->TraceId)
+                            );
+                            if (!Common->EventFilter || Common->EventFilter->CheckIncomingEvent(*fw, Common->LocalScopeId)) {
+                                TActivationContext::Send(fw.release());
+                            }
                         }
                     }
                 }
@@ -322,8 +330,7 @@ namespace NActors {
 
             void HandleSessionEvent(TAutoPtr<IEventHandle> ev) {
                 auto *session = GetSession();
-                InvokeOtherActor(*session, &TSessionMockActor::Receive, ev,
-                    TActivationContext::ActorContextFor(session->SelfId()));
+                InvokeOtherActor(*session, &TSessionMockActor::Receive, ev);
             }
 
             void Disconnect() {
@@ -344,7 +351,7 @@ namespace NActors {
                 return State.Inject(PeerNodeId, std::move(messages), Common->LocalScopeId, Session->SessionId);
             }
 
-            STRICT_STFUNC(StateFunc,
+            STRICT_LIGHTFN(StateFunc,
                 cFunc(TEvents::TSystem::Poison, PassAway)
                 fFunc(TEvInterconnect::EvForward, HandleSessionEvent)
                 fFunc(TEvInterconnect::EvConnectNode, HandleSessionEvent)
diff --git a/library/cpp/actors/interconnect/packet.cpp b/library/cpp/actors/interconnect/packet.cpp
index 9ba173e3302..7b0bdf3e172 100644
--- a/library/cpp/actors/interconnect/packet.cpp
+++ b/library/cpp/actors/interconnect/packet.cpp
@@ -17,14 +17,25 @@ ui32 TEventHolder::Fill(IEventHandle& ev) {
     EventActuallySerialized = 0;
     Descr.Checksum = 0;
 
-    if (ev.HasBuffer()) {
-        Buffer = ev.ReleaseChainBuffer();
-        EventSerializedSize = Buffer->GetSize();
-    } else if (ev.HasEvent()) {
-        Event.Reset(ev.ReleaseBase());
-        EventSerializedSize = Event->CalculateSerializedSize();
+    if (ev.IsEventLight()) {
+        if (ev.IsEventSerializable()) {
+            NActors::IEventHandleLightSerializable& serializable(*NActors::IEventHandleLightSerializable::GetLightSerializable(&ev));
+            EventSerializer = serializable.Serializer;
+            EventSerializedSize = 100;
+        } else {
+            EventSerializedSize = 0;
+        }
     } else {
-        EventSerializedSize = 0;
+        auto& evFat = *IEventHandleFat::GetFat(&ev);
+        if (evFat.HasBuffer()) {
+            Buffer = evFat.ReleaseChainBuffer();
+            EventSerializedSize = Buffer->GetSize();
+        } else if (evFat.HasEvent()) {
+            Event.Reset(evFat.ReleaseBase());
+            EventSerializedSize = Event->CalculateSerializedSize();
+        } else {
+            EventSerializedSize = 0;
+        }
     }
 
     return EventSerializedSize;
diff --git a/library/cpp/actors/interconnect/packet.h b/library/cpp/actors/interconnect/packet.h
index c8909c08a76..c06e6485414 100644
--- a/library/cpp/actors/interconnect/packet.h
+++ b/library/cpp/actors/interconnect/packet.h
@@ -113,6 +113,7 @@ struct TEventHolder : TNonCopyable {
     TActorId ForwardRecipient;
     THolder<IEventBase> Event;
     TIntrusivePtr<TEventSerializedData> Buffer;
+    NActors::TEventSerializer EventSerializer;
     ui64 Serial;
     ui32 EventSerializedSize;
     ui32 EventActuallySerialized;
@@ -137,10 +138,11 @@ struct TEventHolder : TNonCopyable {
         const TActorId& s = d.Sender;
         const TActorId *f = ForwardRecipient ? &ForwardRecipient : nullptr;
         Span.EndError("nondelivery");
-        auto ev = Event
-            ? std::make_unique<IEventHandle>(r, s, Event.Release(), d.Flags, d.Cookie, f, Span.GetTraceId())
-            : std::make_unique<IEventHandle>(d.Type, d.Flags, r, s, std::move(Buffer), d.Cookie, f, Span.GetTraceId());
-        NActors::TActivationContext::Send(ev->ForwardOnNondelivery(NActors::TEvents::TEvUndelivered::Disconnected, unsure));
+        TAutoPtr<IEventHandle> ev = Event
+            ? new IEventHandleFat(r, s, Event.Release(), d.Flags, d.Cookie, f, Span.GetTraceId())
+            : new IEventHandleFat(d.Type, d.Flags, r, s, std::move(Buffer), d.Cookie, f, Span.GetTraceId());
+        ev = IEventHandle::ForwardOnNondelivery(ev, NActors::TEvents::TEvUndelivered::Disconnected, unsure);
+        NActors::TActivationContext::Send(ev);
     }
 
     void Clear() {
diff --git a/library/cpp/actors/interconnect/poller_actor.cpp b/library/cpp/actors/interconnect/poller_actor.cpp
index e75cbcaef43..7161c6ca90e 100644
--- a/library/cpp/actors/interconnect/poller_actor.cpp
+++ b/library/cpp/actors/interconnect/poller_actor.cpp
@@ -104,7 +104,7 @@ namespace NActors {
     protected:
         void Notify(TSocketRecord *record, bool read, bool write) {
             auto issue = [&](const TActorId& recipient) {
-                ActorSystem->Send(new IEventHandle(recipient, {}, new TEvPollerReady(record->Socket, read, write)));
+                ActorSystem->Send(new IEventHandleFat(recipient, {}, new TEvPollerReady(record->Socket, read, write)));
             };
             if (read && record->ReadActorId) {
                 issue(record->ReadActorId);
diff --git a/library/cpp/actors/interconnect/types.h b/library/cpp/actors/interconnect/types.h
index b1d2e02f49d..9a541aeb86b 100644
--- a/library/cpp/actors/interconnect/types.h
+++ b/library/cpp/actors/interconnect/types.h
@@ -64,6 +64,8 @@ namespace NActors {
 
 using NActors::IEventBase;
 using NActors::IEventHandle;
+using NActors::IEventHandleFat;
+using NActors::IEventHandleLight;
 using NActors::TActorId;
 using NActors::TConstIoVec;
 using NActors::TEventSerializedData;
diff --git a/library/cpp/actors/interconnect/ut/channel_scheduler_ut.cpp b/library/cpp/actors/interconnect/ut/channel_scheduler_ut.cpp
index 32c8237b599..561248c3e52 100644
--- a/library/cpp/actors/interconnect/ut/channel_scheduler_ut.cpp
+++ b/library/cpp/actors/interconnect/ut/channel_scheduler_ut.cpp
@@ -20,7 +20,7 @@ Y_UNIT_TEST_SUITE(ChannelScheduler) {
 
         auto pushEvent = [&](size_t size, int channel) {
             TString payload(size, 'X');
-            auto ev = MakeHolder<IEventHandle>(1, 0, TActorId(), TActorId(), MakeIntrusive<TEventSerializedData>(payload, TEventSerializationInfo{}), 0);
+            auto ev = MakeHolder<IEventHandleFat>(1, 0, TActorId(), TActorId(), MakeIntrusive<TEventSerializedData>(payload, TEventSerializationInfo{}), 0);
             auto& ch = scheduler.GetOutputChannel(channel);
             const bool wasWorking = ch.IsWorking();
             ch.Push(*ev);
diff --git a/library/cpp/actors/interconnect/ut/dynamic_proxy_ut.cpp b/library/cpp/actors/interconnect/ut/dynamic_proxy_ut.cpp
index 3c474979dce..78158f07ccc 100644
--- a/library/cpp/actors/interconnect/ut/dynamic_proxy_ut.cpp
+++ b/library/cpp/actors/interconnect/ut/dynamic_proxy_ut.cpp
@@ -106,7 +106,7 @@ void SenderThread(TMutex& lock, TActorSystem *as, ui32 nodeId, ui32 queueId, ui3
     const TActorId target = MakeResponderServiceId(nodeId);
     for (ui32 i = 0; i < count; ++i) {
         const ui32 flags = IEventHandle::FlagTrackDelivery;
-        as->Send(new IEventHandle(TEvents::THelloWorld::Ping, flags, target, sender, nullptr, ((ui64)queueId << 32) | i));
+        as->Send(new IEventHandleFat(TEvents::THelloWorld::Ping, flags, target, sender, nullptr, ((ui64)queueId << 32) | i));
     }
 }
 
diff --git a/library/cpp/actors/interconnect/ut/interconnect_ut.cpp b/library/cpp/actors/interconnect/ut/interconnect_ut.cpp
index 3596bffd5ac..000f5d4b3e9 100644
--- a/library/cpp/actors/interconnect/ut/interconnect_ut.cpp
+++ b/library/cpp/actors/interconnect/ut/interconnect_ut.cpp
@@ -46,25 +46,30 @@ public:
             }
             const TSessionToCookie::iterator s2cIt = SessionToCookie.emplace(SessionId, NextCookie);
             InFlight.emplace(NextCookie, std::make_tuple(s2cIt, MD5::CalcRaw(data)));
-            TActivationContext::Send(new IEventHandle(TEvents::THelloWorld::Ping, IEventHandle::FlagTrackDelivery, Recipient,
+            TActivationContext::Send(new IEventHandleFat(TEvents::THelloWorld::Ping, IEventHandle::FlagTrackDelivery, Recipient,
                 SelfId(), MakeIntrusive<TEventSerializedData>(std::move(data), TEventSerializationInfo{}), NextCookie));
 //            Cerr << (TStringBuilder() << "Send# " << NextCookie << Endl);
             ++NextCookie;
         }
     }
 
-    void HandlePong(TAutoPtr<IEventHandle> ev) {
+    void HandlePong(TAutoPtr<IEventHandle> e) {
 //        Cerr << (TStringBuilder() << "Receive# " << ev->Cookie << Endl);
-        if (const auto it = InFlight.find(ev->Cookie); it != InFlight.end()) {
-            auto& [s2cIt, hash] = it->second;
-            Y_VERIFY(hash == ev->GetChainBuffer()->GetString());
-            SessionToCookie.erase(s2cIt);
-            InFlight.erase(it);
-        } else if (const auto it = Tentative.find(ev->Cookie); it != Tentative.end()) {
-            Y_VERIFY(it->second == ev->GetChainBuffer()->GetString());
-            Tentative.erase(it);
+        if (e->IsEventFat()) {
+            auto ev = IEventHandleFat::GetFat(e);
+            if (const auto it = InFlight.find(ev->Cookie); it != InFlight.end()) {
+                auto& [s2cIt, hash] = it->second;
+                Y_VERIFY(hash == ev->GetChainBuffer()->GetString());
+                SessionToCookie.erase(s2cIt);
+                InFlight.erase(it);
+            } else if (const auto it = Tentative.find(ev->Cookie); it != Tentative.end()) {
+                Y_VERIFY(it->second == ev->GetChainBuffer()->GetString());
+                Tentative.erase(it);
+            } else {
+                Y_FAIL("Cookie# %" PRIu64, ev->Cookie);
+            }
         } else {
-            Y_FAIL("Cookie# %" PRIu64, ev->Cookie);
+            Y_FAIL("Pong is not fat");
         }
         IssueQueries();
     }
@@ -123,10 +128,13 @@ public:
     {}
 
     void HandlePing(TAutoPtr<IEventHandle>& ev) {
-        const TString& data = ev->GetChainBuffer()->GetString();
-        const TString& response = MD5::CalcRaw(data);
-        TActivationContext::Send(new IEventHandle(TEvents::THelloWorld::Pong, 0, ev->Sender, SelfId(),
-            MakeIntrusive<TEventSerializedData>(response, TEventSerializationInfo{}), ev->Cookie));
+        if (ev->IsEventFat()) {
+            auto* evf = IEventHandleFat::GetFat(ev);
+            const TString& data = evf->GetChainBuffer()->GetString();
+            const TString& response = MD5::CalcRaw(data);
+            TActivationContext::Send(new IEventHandleFat(TEvents::THelloWorld::Pong, 0, evf->Sender, SelfId(),
+                MakeIntrusive<TEventSerializedData>(response, TEventSerializationInfo{}), evf->Cookie));
+        }
     }
 
     STRICT_STFUNC(StateFunc,
diff --git a/library/cpp/actors/interconnect/ut/poller_actor_ut.cpp b/library/cpp/actors/interconnect/ut/poller_actor_ut.cpp
index 23d846a2fd8..745a020d2a2 100644
--- a/library/cpp/actors/interconnect/ut/poller_actor_ut.cpp
+++ b/library/cpp/actors/interconnect/ut/poller_actor_ut.cpp
@@ -253,7 +253,7 @@ public:
 private:
     void RegisterSocket(TTestSocketPtr socket, TActorId readActorId, TActorId writeActorId) {
         auto ev = new TEvPollerRegister{socket, readActorId, writeActorId};
-        ActorSystem_->Send(new IEventHandle(PollerId_, TActorId{}, ev));
+        ActorSystem_->Send(new IEventHandleFat(PollerId_, TActorId{}, ev));
     }
 
 private:
diff --git a/library/cpp/actors/testlib/decorator_ut.cpp b/library/cpp/actors/testlib/decorator_ut.cpp
index e9a2fa35604..3c70d25ec00 100644
--- a/library/cpp/actors/testlib/decorator_ut.cpp
+++ b/library/cpp/actors/testlib/decorator_ut.cpp
@@ -28,14 +28,14 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
 
         virtual ~TDyingChecker() {
             Write("TDyingChecker::~TDyingChecker");
-            TActivationContext::Send(new IEventHandle(MasterId, SelfId(), new TEvents::TEvPing()));
+            TActivationContext::Send(new IEventHandleFat(MasterId, SelfId(), new TEvents::TEvPing()));
         }
 
         bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
             Write("TDyingChecker::DoBeforeReceiving");
             return true;
         }
-        
+
         void DoAfterReceiving(const TActorContext &/*ctx*/) override {
             Write("TDyingChecker::DoAfterReceiving");
         }
@@ -47,7 +47,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
         TSet<TActorId> ActorIds;
         TVector<THolder<IActor>> Actors;
         TActorId EdgeActor;
-        
+
         TTestMasterActor(TVector<THolder<IActor>> &&actors, TActorId edgeActor)
             : TActorBootstrapped()
             , Actors(std::move(actors))
@@ -104,7 +104,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
                 return true;
             }
             Write("TFizzBuzzToFooBar::DoBeforeSending");
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            TEventHandleFat<TEvWords> *handle = reinterpret_cast<TEventHandleFat<TEvWords>*>(ev.Get());
             UNIT_ASSERT(handle);
             TEvWords *event = handle->Get();
             TVector<TString> &words = event->Words;
@@ -124,12 +124,12 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
             Write("TFizzBuzzToFooBar::DoBeforeReceiving");
             return true;
         }
-        
+
         void DoAfterReceiving(const TActorContext &/*ctx*/) override {
             Write("TFizzBuzzToFooBar::DoAfterReceiving");
         }
-    };    
-    
+    };
+
     struct TWordEraser : TTestDecorator {
         TString ErasingWord;
 
@@ -144,7 +144,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
                 return true;
             }
             Write("TWordEraser::DoBeforeSending");
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            TEventHandleFat<TEvWords> *handle = reinterpret_cast<TEventHandleFat<TEvWords>*>(ev.Get());
             UNIT_ASSERT(handle);
             TEvWords *event = handle->Get();
             TVector<TString> &words = event->Words;
@@ -159,7 +159,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
             Write("TWordEraser::DoBeforeReceiving");
             return true;
         }
-        
+
         void DoAfterReceiving(const TActorContext &/*ctx*/) override {
             Write("TWordEraser::DoAfterReceiving");
         }
@@ -176,7 +176,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
                 return true;
             }
             Write("TWithoutWordsDroper::DoBeforeSending");
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            TEventHandleFat<TEvWords> *handle = reinterpret_cast<TEventHandleFat<TEvWords>*>(ev.Get());
             UNIT_ASSERT(handle);
             TEvWords *event = handle->Get();
             return bool(event->Words);
@@ -186,7 +186,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
             Write("TWithoutWordsDroper::DoBeforeReceiving");
             return true;
         }
-        
+
         void DoAfterReceiving(const TActorContext &/*ctx*/) override {
             Write("TWithoutWordsDroper::DoAfterReceiving");
         }
@@ -208,7 +208,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
         }
 
         STATEFN(State) {
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            TEventHandleFat<TEvWords> *handle = reinterpret_cast<TEventHandleFat<TEvWords>*>(ev.Get());
             UNIT_ASSERT(handle);
             UNIT_ASSERT(handle->Sender == MasterId);
             TEvWords *event = handle->Get();
@@ -284,7 +284,7 @@ Y_UNIT_TEST_SUITE(TesTTestDecorator) {
             return true;
         }
     };
-    
+
     bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event,
             TDuration delay, TInstant& deadline) {
         if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) {
diff --git a/library/cpp/actors/testlib/test_runtime.cpp b/library/cpp/actors/testlib/test_runtime.cpp
index ad124bf258b..889edc4969b 100644
--- a/library/cpp/actors/testlib/test_runtime.cpp
+++ b/library/cpp/actors/testlib/test_runtime.cpp
@@ -47,11 +47,11 @@ namespace NActors {
             Cerr << " \"" << name << "\"";
         Cerr << ", ";
         if (ev->HasEvent())
-            Cerr << " : " << (PRINT_EVENT_BODY ? ev->GetBase()->ToString() : ev->GetBase()->ToStringHeader());
-        else if (ev->HasBuffer())
-            Cerr << " : BUFFER";
-        else
-            Cerr << " : EMPTY";
+            Cerr << " : " << (PRINT_EVENT_BODY ? ev->ToString() : ev->GetTypeName());
+        // else if (ev->HasBuffer())
+        //     Cerr << " : BUFFER";
+        // else
+        //     Cerr << " : EMPTY";
 
         Cerr << "\n";
     }
@@ -397,7 +397,7 @@ namespace NActors {
                             TActorContext ctx(*mailbox, *node->ExecutorThread, GetCycleCountFast(), ev->GetRecipientRewrite());
                             TActivationContext *prevTlsActivationContext = TlsActivationContext;
                             TlsActivationContext = &ctx;
-                            recipientActor->Receive(ev, ctx);
+                            recipientActor->Receive(ev);
                             TlsActivationContext = prevTlsActivationContext;
                             // we expect the logger to never die in tests
                         }
@@ -669,7 +669,7 @@ namespace NActors {
         while (!scheduledEvents.empty() && scheduledEvents.begin()->Deadline == time) {
 //            static THashMap<std::pair<TActorId, TString>, ui64> eventTypes;
             auto& item = *scheduledEvents.begin();
-            TString name = item.Event->GetBase() ? TypeName(*item.Event->GetBase()) : Sprintf("%08" PRIx32, item.Event->Type);
+            TString name = item.Event->GetTypeName();
 //            eventTypes[std::make_pair(item.Event->Recipient, name)]++;
             runtime.ScheduledCount++;
             if (runtime.ScheduledCount > runtime.ScheduledLimit) {
@@ -1420,18 +1420,23 @@ namespace NActors {
         }
     }
 
-    void TTestActorRuntimeBase::Send(IEventHandle* ev, ui32 senderNodeIndex, bool viaActorSystem) {
+    void TTestActorRuntimeBase::Send(const TActorId& recipient, const TActorId& sender, TAutoPtr<IEventHandleLight> ev, ui32 senderNodeIndex, bool viaActorSystem) {
+        ev->PrepareSend(recipient, sender);
+        Send(ev.Release(), senderNodeIndex, viaActorSystem);
+    }
+
+    void TTestActorRuntimeBase::Send(TAutoPtr<IEventHandle> ev, ui32 senderNodeIndex, bool viaActorSystem) {
         TGuard<TMutex> guard(Mutex);
         Y_VERIFY(senderNodeIndex < NodeCount, "senderNodeIndex# %" PRIu32 " < NodeCount# %" PRIu32,
             senderNodeIndex, NodeCount);
         SendInternal(ev, senderNodeIndex, viaActorSystem);
     }
 
-    void TTestActorRuntimeBase::SendAsync(IEventHandle* ev, ui32 senderNodeIndex) {
+    void TTestActorRuntimeBase::SendAsync(TAutoPtr<IEventHandle> ev, ui32 senderNodeIndex) {
         Send(ev, senderNodeIndex, true);
     }
 
-    void TTestActorRuntimeBase::Schedule(IEventHandle* ev, const TDuration& duration, ui32 nodeIndex) {
+    void TTestActorRuntimeBase::Schedule(TAutoPtr<IEventHandle> ev, const TDuration& duration, ui32 nodeIndex) {
         TGuard<TMutex> guard(Mutex);
         Y_VERIFY(nodeIndex < NodeCount);
         ui32 nodeId = FirstNodeId + nodeIndex;
@@ -1568,7 +1573,7 @@ namespace NActors {
         NeedMonitoring = true;
     }
 
-    void TTestActorRuntimeBase::SendInternal(IEventHandle* ev, ui32 nodeIndex, bool viaActorSystem) {
+    void TTestActorRuntimeBase::SendInternal(TAutoPtr<IEventHandle> ev, ui32 nodeIndex, bool viaActorSystem) {
         Y_VERIFY(nodeIndex < NodeCount);
         ui32 nodeId = FirstNodeId + nodeIndex;
         TNodeDataBase* node = Nodes[nodeId].Get();
@@ -1587,23 +1592,22 @@ namespace NActors {
         }
 
         Y_VERIFY(!ev->GetRecipientRewrite().IsService() && (targetNodeIndex == nodeIndex));
-        TAutoPtr<IEventHandle> evHolder(ev);
 
-        if (!AllowSendFrom(node, evHolder)) {
+        if (!AllowSendFrom(node, ev)) {
             return;
         }
 
         ui32 mailboxHint = ev->GetRecipientRewrite().Hint();
         TEventMailBox& mbox = GetMailbox(nodeId, mailboxHint);
         if (!mbox.IsActive(TInstant::MicroSeconds(CurrentTimestamp))) {
-            mbox.PushFront(evHolder);
+            mbox.PushFront(ev);
             return;
         }
 
         ui64 recipientLocalId = ev->GetRecipientRewrite().LocalId();
         if ((BlockedOutput.find(ev->Sender) == BlockedOutput.end()) && VERBOSE) {
             Cerr << "Send event, ";
-            PrintEvent(evHolder, this);
+            PrintEvent(ev, this);
         }
 
         EvCounters[ev->GetTypeRewrite()]++;
@@ -1624,7 +1628,7 @@ namespace NActors {
                 TCallstack::GetTlsCallstack() = ev->Callstack;
                 TCallstack::GetTlsCallstack().SetLinesToSkip();
 #endif
-                recipientActor->Receive(evHolder, ctx);
+                recipientActor->Receive(ev);
                 node->ExecutorThread->DropUnregistered();
             }
             CurrentRecipient = TActorId();
@@ -1634,10 +1638,8 @@ namespace NActors {
                 Cerr << "Failed to find actor with local id: " << recipientLocalId << "\n";
             }
 
-            auto forwardedEv = ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown);
-            if (!!forwardedEv) {
-                node->ActorSystem->Send(forwardedEv);
-            }
+            auto fw = IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown);
+            node->ActorSystem->Send(fw);
         }
     }
 
@@ -1864,7 +1866,8 @@ namespace NActors {
             if (HasReply) {
                 delete Context->Queue->Pop();
             }
-            ctx.ExecutorThread.Send(ev->Forward(originalSender));
+            IEventHandle::Forward(ev, originalSender);
+            ctx.ExecutorThread.Send(ev);
             if (!IsSync && Context->Queue->Head()) {
                 SendHead(ctx);
             }
@@ -1896,9 +1899,17 @@ namespace NActors {
         TAutoPtr<IEventHandle> GetForwardedEvent() {
             IEventHandle* ev = Context->Queue->Head();
             ReplyChecker->OnRequest(ev);
-            TAutoPtr<IEventHandle> forwardedEv = ev->HasEvent()
-                ? new IEventHandle(Delegatee, ReplyId, ev->ReleaseBase().Release(), ev->Flags, ev->Cookie)
-                : new IEventHandle(ev->GetTypeRewrite(), ev->Flags, Delegatee, ReplyId, ev->ReleaseChainBuffer(), ev->Cookie);
+            TAutoPtr<IEventHandle> forwardedEv;
+            if (ev->IsEventLight()) {
+                IEventHandleLight* evl = IEventHandleLight::GetLight(ev);
+                evl->PrepareSend(Delegatee, ReplyId);
+                forwardedEv = ev;
+            } else {
+                IEventHandleFat* evf = IEventHandleFat::GetFat(ev);
+                forwardedEv = ev->HasEvent()
+                    ? new IEventHandleFat(Delegatee, ReplyId, evf->ReleaseBase().Release(), evf->Flags, evf->Cookie)
+                    : new IEventHandleFat(evf->GetTypeRewrite(), evf->Flags, Delegatee, ReplyId, evf->ReleaseChainBuffer(), evf->Cookie);
+            }
 
             return forwardedEv;
         }
diff --git a/library/cpp/actors/testlib/test_runtime.h b/library/cpp/actors/testlib/test_runtime.h
index 343b417b35e..c48708b975b 100644
--- a/library/cpp/actors/testlib/test_runtime.h
+++ b/library/cpp/actors/testlib/test_runtime.h
@@ -260,9 +260,10 @@ namespace NActors {
         bool DispatchEvents(const TDispatchOptions& options = TDispatchOptions());
         bool DispatchEvents(const TDispatchOptions& options, TDuration simTimeout);
         bool DispatchEvents(const TDispatchOptions& options, TInstant simDeadline);
-        void Send(IEventHandle* ev, ui32 senderNodeIndex = 0, bool viaActorSystem = false);
-        void SendAsync(IEventHandle* ev, ui32 senderNodeIndex = 0);
-        void Schedule(IEventHandle* ev, const TDuration& duration, ui32 nodeIndex = 0);
+        void Send(const TActorId& recipient, const TActorId& sender, TAutoPtr<IEventHandleLight> ev, ui32 senderNodeIndex = 0, bool viaActorSystem = false);
+        void Send(TAutoPtr<IEventHandle> ev, ui32 senderNodeIndex = 0, bool viaActorSystem = false);
+        void SendAsync(TAutoPtr<IEventHandle> ev, ui32 senderNodeIndex = 0);
+        void Schedule(TAutoPtr<IEventHandle> ev, const TDuration& duration, ui32 nodeIndex = 0);
         void ClearCounters();
         ui64 GetCounter(ui32 evType) const;
         TActorId GetLocalServiceId(const TActorId& serviceId, ui32 nodeIndex = 0);
@@ -301,7 +302,7 @@ namespace NActors {
                 if (event->GetTypeRewrite() != eventType)
                     return false;
 
-                TEvent* typedEvent = reinterpret_cast<TAutoPtr<TEventHandle<TEvent>>&>(event)->Get();
+                TEvent* typedEvent = event->Get<TEvent>();
                 if (predicate(*typedEvent)) {
                     handle = event;
                     return true;
@@ -314,7 +315,7 @@ namespace NActors {
                 Y_VERIFY(handle);
 
             if (handle) {
-                return reinterpret_cast<TAutoPtr<TEventHandle<TEvent>>&>(handle)->Get();
+                return handle->Get<TEvent>();
             } else {
                 return nullptr;
             }
@@ -369,7 +370,10 @@ namespace NActors {
             TAutoPtr<IEventHandle> handle;
             std::function<bool(const TEvent&)> truth = [](const TEvent&) { return true; };
             GrabEdgeEventIf(handle, truth, simTimeout);
-            return THolder(handle ? handle->Release<TEvent>().Release() : nullptr);
+            if (handle) {
+                return THolder<TEvent>(IEventHandle::Release<TEvent>(handle));
+            }
+            return {};
         }
 
         template<class TEvent>
@@ -398,7 +402,7 @@ namespace NActors {
                 Y_VERIFY(handle);
             if (handle) {
                 return std::make_tuple(handle->Type == TEvents::EventType
-                                       ? reinterpret_cast<TAutoPtr<TEventHandle<TEvents>>&>(handle)->Get()
+                                       ? handle->Get<TEvents>()
                                        : static_cast<TEvents*>(nullptr)...);
             }
             return {};
@@ -503,7 +507,7 @@ namespace NActors {
 
    private:
         IActor* FindActor(const TActorId& actorId, TNodeDataBase* node) const;
-        void SendInternal(IEventHandle* ev, ui32 nodeIndex, bool viaActorSystem);
+        void SendInternal(TAutoPtr<IEventHandle> ev, ui32 nodeIndex, bool viaActorSystem);
         TEventMailBox& GetMailbox(ui32 nodeId, ui32 hint);
         void ClearMailbox(ui32 nodeId, ui32 hint);
         void HandleNonEmptyMailboxesForEachContext(TEventMailboxId mboxId);
@@ -647,7 +651,7 @@ namespace NActors {
     TEvent* FindEvent(TEventsList& events) {
         for (auto& event : events) {
             if (event && event->GetTypeRewrite() == TEvent::EventType) {
-                return static_cast<TEvent*>(event->GetBase());
+                return event->CastAsLocal<TEvent>();
             }
         }
 
@@ -657,8 +661,8 @@ namespace NActors {
     template <typename TEvent>
     TEvent* FindEvent(TEventsList& events, const std::function<bool(const TEvent&)>& predicate) {
         for (auto& event : events) {
-            if (event && event->GetTypeRewrite() == TEvent::EventType && predicate(*static_cast<TEvent*>(event->GetBase()))) {
-                return static_cast<TEvent*>(event->GetBase());
+            if (event && event->GetTypeRewrite() == TEvent::EventType && predicate(*event->CastAsLocal<TEvent>())) {
+                return event->CastAsLocal<TEvent>();
             }
         }
 
@@ -671,7 +675,7 @@ namespace NActors {
         for (auto& event : events) {
             if (event && event->GetTypeRewrite() == TEvent::EventType) {
                 ev = event;
-                return static_cast<TEvent*>(ev->GetBase());
+                return ev->CastAsLocal<TEvent>();
             }
         }
 
@@ -686,7 +690,7 @@ namespace NActors {
             if (event && event->GetTypeRewrite() == TEvent::EventType) {
                 if (predicate(reinterpret_cast<const typename TEvent::TPtr&>(event))) {
                     ev = event;
-                    return static_cast<TEvent*>(ev->GetBase());
+                    return ev->CastAsLocal<TEvent>();
                 }
             }
         }
diff --git a/library/cpp/actors/wilson/wilson_span.cpp b/library/cpp/actors/wilson/wilson_span.cpp
index dcd458be7c6..42aa3a6fbdb 100644
--- a/library/cpp/actors/wilson/wilson_span.cpp
+++ b/library/cpp/actors/wilson/wilson_span.cpp
@@ -54,7 +54,7 @@ namespace NWilson {
 
     void TSpan::Send() {
         if (TlsActivationContext) {
-            TActivationContext::Send(new IEventHandle(MakeWilsonUploaderId(), {}, new TEvWilson(&Data->Span)));
+            TActivationContext::Send(new IEventHandleFat(MakeWilsonUploaderId(), {}, new TEvWilson(&Data->Span)));
         }
         Data->Sent = true;
     }
diff --git a/library/cpp/actors/wilson/wilson_uploader.cpp b/library/cpp/actors/wilson/wilson_uploader.cpp
index e6db248b972..b9b4ee2b210 100644
--- a/library/cpp/actors/wilson/wilson_uploader.cpp
+++ b/library/cpp/actors/wilson/wilson_uploader.cpp
@@ -145,7 +145,7 @@ namespace NWilson {
                     bool ok;
                     if (CQ.AsyncNext(&tag, &ok, std::chrono::system_clock::now()) == grpc::CompletionQueue::GOT_EVENT) {
                         if (!Status.ok()) {
-                            LOG_ERROR_S(*TlsActivationContext, 430 /* NKikimrServices::WILSON */, 
+                            LOG_ERROR_S(*TlsActivationContext, 430 /* NKikimrServices::WILSON */,
                                 "failed to commit traces: " << Status.error_message());
                         }
 
@@ -160,7 +160,7 @@ namespace NWilson {
             template<typename T>
             void ScheduleWakeup(T&& deadline) {
                 if (!WakeupScheduled) {
-                    TActivationContext::Schedule(deadline, new IEventHandle(TEvents::TSystem::Wakeup, 0, SelfId(), {},
+                    TActivationContext::Schedule(deadline, new IEventHandleFat(TEvents::TSystem::Wakeup, 0, SelfId(), {},
                         nullptr, 0));
                     WakeupScheduled = true;
                 }
diff --git a/ydb/core/actorlib_impl/actor_activity_ut.cpp b/ydb/core/actorlib_impl/actor_activity_ut.cpp
index 119aa539781..1148a69380f 100644
--- a/ydb/core/actorlib_impl/actor_activity_ut.cpp
+++ b/ydb/core/actorlib_impl/actor_activity_ut.cpp
@@ -18,7 +18,7 @@ public:
     }
 
     TTestActor()
-        : TActor(nullptr)
+        : TActor(TActorCallback<TTestActor>::TFatReceiveFunc(nullptr))
     { }
 };
 
diff --git a/ydb/core/actorlib_impl/actor_tracker.cpp b/ydb/core/actorlib_impl/actor_tracker.cpp
index 273d821f754..43efe29966f 100644
--- a/ydb/core/actorlib_impl/actor_tracker.cpp
+++ b/ydb/core/actorlib_impl/actor_tracker.cpp
@@ -181,7 +181,7 @@ namespace NActors {
 
     TAutoPtr<IEventHandle> TTrackedActorBase::AfterRegister(const TActorId& self, const TActorId& parent) {
         // send TEvBootstrap event locally
-        return new IEventHandle(self, parent, new TEvents::TEvBootstrap);
+        return new IEventHandleFat(self, parent, new TEvents::TEvBootstrap);
     }
 
     void TTrackedActorBase::InitialReceiveFunc(TAutoPtr<IEventHandle>& ev, const TActorContext& ctx) {
diff --git a/ydb/core/actorlib_impl/actor_tracker_ut.cpp b/ydb/core/actorlib_impl/actor_tracker_ut.cpp
index d804e3b9240..583f29060fa 100644
--- a/ydb/core/actorlib_impl/actor_tracker_ut.cpp
+++ b/ydb/core/actorlib_impl/actor_tracker_ut.cpp
@@ -107,7 +107,7 @@ Y_UNIT_TEST_SUITE(TActorTracker) {
             runtime.Initialize(NKikimr::TAppPrepare().Unwrap());
             TActorId managerId = runtime.Register(new TManagerActor);
             TActorId edge = runtime.AllocateEdgeActor();
-            runtime.Schedule(new IEventHandle(managerId, edge, new TEvents::TEvPoisonPill), TDuration::Seconds(1));
+            runtime.Schedule(new IEventHandleFat(managerId, edge, new TEvents::TEvPoisonPill), TDuration::Seconds(1));
             runtime.DispatchEvents();
             TAutoPtr<IEventHandle> handle;
             runtime.GrabEdgeEventRethrow<TEvents::TEvPoisonTaken>(handle);
diff --git a/ydb/core/actorlib_impl/connect_socket_protocol.cpp b/ydb/core/actorlib_impl/connect_socket_protocol.cpp
index c4c6db9f13b..e57a935bb7b 100644
--- a/ydb/core/actorlib_impl/connect_socket_protocol.cpp
+++ b/ydb/core/actorlib_impl/connect_socket_protocol.cpp
@@ -20,7 +20,7 @@ void TConnectSocketProtocol::ProtocolFunc(
 
     case TEvSocketError::EventType:
         {
-            auto errorMsg = ev->Get<TEvSocketError>();
+            auto errorMsg = IEventHandleFat::GetFat(ev)->Get<TEvSocketError>();
             if (Socket.Get() == errorMsg->Socket.Get())
                 CheckConnectResult(ctx, errorMsg->Error);
         }
diff --git a/ydb/core/actorlib_impl/long_timer.cpp b/ydb/core/actorlib_impl/long_timer.cpp
index 3a374ab8e71..ace9f14aa2a 100644
--- a/ydb/core/actorlib_impl/long_timer.cpp
+++ b/ydb/core/actorlib_impl/long_timer.cpp
@@ -74,7 +74,7 @@ public:
         TMonotonic signalTime = now + delta;
         ui64 semirandomNumber = parentId.LocalId();
         const TActorId timerActorID = ctx.ExecutorThread.ActorSystem->Register(new TLongTimer(now, signalTime, ev, cookie), TMailboxType::HTSwap, poolId, semirandomNumber, parentId);
-        ctx.ExecutorThread.Schedule(TDuration::Seconds(ThresholdSec), new IEventHandle(timerActorID, timerActorID, new TEvents::TEvWakeup()));
+        ctx.ExecutorThread.Schedule(TDuration::Seconds(ThresholdSec), new IEventHandleFat(timerActorID, timerActorID, new TEvents::TEvWakeup()));
 
         return timerActorID;
     }
@@ -93,7 +93,7 @@ public:
         TMonotonic now = TActivationContext::Monotonic();
         TMonotonic signalTime = now + delta;
         const TActorId timerActorID = TActivationContext::Register(new TLongTimer(now, signalTime, ev, cookie), TActorId(), TMailboxType::HTSwap, poolId);
-        TActivationContext::Schedule(TDuration::Seconds(ThresholdSec), new IEventHandle(timerActorID, timerActorID, new TEvents::TEvWakeup()));
+        TActivationContext::Schedule(TDuration::Seconds(ThresholdSec), new IEventHandleFat(timerActorID, timerActorID, new TEvents::TEvWakeup()));
 
         return timerActorID;
     }
diff --git a/ydb/core/actorlib_impl/mad_squirrel.cpp b/ydb/core/actorlib_impl/mad_squirrel.cpp
index 3f9629d0996..bb9014adfcc 100644
--- a/ydb/core/actorlib_impl/mad_squirrel.cpp
+++ b/ydb/core/actorlib_impl/mad_squirrel.cpp
@@ -6,7 +6,7 @@ namespace NActors {
 
 class TMadSquirrel : public TActor<TMadSquirrel> {
     TAutoPtr<IEventHandle> AfterRegister(const TActorId &self, const TActorId &) override {
-        return new IEventHandle(self, self, new TEvents::TEvWakeup());
+        return new IEventHandleFat(self, self, new TEvents::TEvWakeup());
     }
 
 public:
diff --git a/ydb/core/actorlib_impl/name_service_client_protocol.cpp b/ydb/core/actorlib_impl/name_service_client_protocol.cpp
index 682bc3b44e2..ce0095bccd2 100644
--- a/ydb/core/actorlib_impl/name_service_client_protocol.cpp
+++ b/ydb/core/actorlib_impl/name_service_client_protocol.cpp
@@ -9,16 +9,17 @@ void TResolveClientProtocol::ProtocolFunc(
     switch (ev->GetTypeRewrite()) {
 
     case TEvAddressInfo::EventType:
-        Y_VERIFY(ev->Get<TEvAddressInfo>() != nullptr);
-        Y_VERIFY(ev->Get<TEvAddressInfo>()->Address.Get() != nullptr);
+        Y_VERIFY(ev->IsEventFat());
+        Y_VERIFY(IEventHandleFat::GetFat(ev)->Get<TEvAddressInfo>() != nullptr);
+        Y_VERIFY(IEventHandleFat::GetFat(ev)->Get<TEvAddressInfo>()->Address.Get() != nullptr);
 
         MemLogPrintF("TResolveClientProtocol received address info");
 
-        CatchHostAddress(ctx, std::move(ev->Get<TEvAddressInfo>()->Address));
+        CatchHostAddress(ctx, std::move(IEventHandleFat::GetFat(ev)->Get<TEvAddressInfo>()->Address));
         break;
 
     case TEvResolveError::EventType:
-        CatchResolveError(ctx, std::move(ev->Get<TEvResolveError>()->Explain));
+        CatchResolveError(ctx, std::move(IEventHandleFat::GetFat(ev)->Get<TEvResolveError>()->Explain));
         break;
 
     default:
diff --git a/ydb/core/actorlib_impl/router_rr.h b/ydb/core/actorlib_impl/router_rr.h
index f78f61d2be5..463deaae281 100644
--- a/ydb/core/actorlib_impl/router_rr.h
+++ b/ydb/core/actorlib_impl/router_rr.h
@@ -55,7 +55,7 @@ namespace NActors {
 
         virtual TAutoPtr<NActors::IEventHandle> AfterRegister(const NActors::TActorId &self, const TActorId& parentId) override {
             Y_UNUSED(parentId);
-            return new NActors::IEventHandle(self, self, new TEvents::TEvBootstrap(), 0);
+            return new NActors::IEventHandleFat(self, self, new TEvents::TEvBootstrap(), 0);
         }
 
     protected:
diff --git a/ydb/core/actorlib_impl/test_interconnect_ut.cpp b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
index 99e141c6aa1..8ccdc059dc8 100644
--- a/ydb/core/actorlib_impl/test_interconnect_ut.cpp
+++ b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
@@ -46,7 +46,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
 
     private:
         STFUNC(StateFunc) {
-            ctx.Send(ev->InterconnectSession, new TEvents::TEvPoisonPill);
+            ctx.Send(IEventHandleFat::GetFat(ev)->InterconnectSession, new TEvents::TEvPoisonPill);
         }
     };
 
@@ -76,7 +76,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         }
 
         TAutoPtr<IEventHandle> AfterRegister(const TActorId &self, const TActorId& parentId) noexcept override {
-            return new IEventHandle(self, parentId, new TEvents::TEvBootstrap, 0);
+            return new IEventHandleFat(self, parentId, new TEvents::TEvBootstrap, 0);
         }
 
         void OnStart(const NActors::TActorContext &ctx) noexcept {
@@ -107,12 +107,13 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         unsigned Responses;
     };
 
-    TAutoPtr<IEventHandle> GetSerialized(const TAutoPtr<IEventHandle>& ev) {
+    TAutoPtr<IEventHandle> GetSerialized(const TAutoPtr<IEventHandle>& e) {
+        auto* ev = IEventHandleFat::GetFat(e.Get());
         NActors::TAllocChunkSerializer chunker;
         ev->GetBase()->SerializeToArcadiaStream(&chunker);
         auto Data = chunker.Release(ev->GetBase()->CreateSerializationInfo());
         TAutoPtr<IEventHandle> serev =
-            new IEventHandle(ev->GetBase()->Type(), ev->Flags,
+            new IEventHandleFat(ev->GetBase()->Type(), ev->Flags,
                              ev->Recipient, ev->Sender,
                              std::move(Data), ev->Cookie);
         return serev;
@@ -126,7 +127,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         const auto edge = runtime.AllocateEdgeActor(0);
         const auto wall = runtime.Register(new TWall, 1);
 
-        runtime.Send(new IEventHandle(wall, edge, new TEvents::TEvPing, 7 << IEventHandle::ChannelShift, 13), 0);
+        runtime.Send(new IEventHandleFat(wall, edge, new TEvents::TEvPing, 7 << IEventHandle::ChannelShift, 13), 0);
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvents::TEvPong>(handle);
         UNIT_ASSERT_EQUAL(handle->Cookie, 13);
@@ -170,7 +171,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         TTestBasicRuntime runtime(2);
         runtime.Initialize(TAppPrepare().Unwrap());
         const auto edge = runtime.AllocateEdgeActor(0);
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
 
         TAutoPtr<IEventHandle> handle;
         {
@@ -178,7 +179,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
             UNIT_ASSERT_EQUAL(event->NodeId, runtime.GetNodeId(1));
         }
 
-        runtime.Send(new IEventHandle(handle->Sender, edge, new TEvents::TEvPoisonPill), 0, true);
+        runtime.Send(new IEventHandleFat(handle->Sender, edge, new TEvents::TEvPoisonPill), 0, true);
 
         {
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeDisconnected>(handle);
@@ -196,7 +197,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         for (auto i = 0U; i < blob.size(); ++i)
              const_cast<TString::value_type*>(blob.data())[i] = TString::value_type(i % 256);
 
-        runtime.Send(new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, 13), 0);
+        runtime.Send(new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, 13), 0);
 
         TAutoPtr<IEventHandle> handle;
         const auto event = runtime.GrabEdgeEvent<TEvents::TEvBlob>(handle);
@@ -218,7 +219,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         for (int count = 0; count < 100; ++count) {
             NActors::TAllocChunkSerializer chunker;
             TAutoPtr<IEventHandle> raw =
-                new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, 13);
+                new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, 13);
             TAutoPtr<IEventHandle> serev = GetSerialized(raw);
 
             runtime.Send(serev.Release(), 0);
@@ -238,13 +239,13 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
 
         const TString blob(10000000, '#');
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge0, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge0, new TEvInterconnect::TEvConnectNode), 0, true);
 
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
 
-        runtime.Send(new IEventHandle(edge1, edge0, new TEvents::TEvBlob(blob), IEventHandle::FlagTrackDelivery, 777), 0, true);
-        runtime.Send(new IEventHandle(handle->Sender, edge0, new TEvents::TEvPoisonPill), 0, true);
+        runtime.Send(new IEventHandleFat(edge1, edge0, new TEvents::TEvBlob(blob), IEventHandle::FlagTrackDelivery, 777), 0, true);
+        runtime.Send(new IEventHandleFat(handle->Sender, edge0, new TEvents::TEvPoisonPill), 0, true);
         const auto event = runtime.GrabEdgeEvent<TEvents::TEvUndelivered>(handle);
         UNIT_ASSERT_EQUAL(handle->Cookie, 777);
         UNIT_ASSERT_EQUAL(event->SourceType, TEvents::TEvBlob::EventType);
@@ -257,7 +258,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         const auto edge = runtime.AllocateEdgeActor(0);
         const auto wall = runtime.Register(new TKiller, 1);
 
-        runtime.Send(new IEventHandle(wall, edge, new TEvents::TEvPing, IEventHandle::FlagSubscribeOnSession), 0);
+        runtime.Send(new IEventHandleFat(wall, edge, new TEvents::TEvPing, IEventHandle::FlagSubscribeOnSession), 0);
         {
             TAutoPtr<IEventHandle> handle;
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
@@ -287,21 +288,21 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         const auto edge = runtime.AllocateEdgeActor(0);
         const auto wall = runtime.Register(new TWall, 1);
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
 
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
         const auto session = handle->Sender;
 
-        runtime.Send(new IEventHandle(wall, edge, new TEvents::TEvPing), 0, true);
+        runtime.Send(new IEventHandleFat(wall, edge, new TEvents::TEvPing), 0, true);
         runtime.GrabEdgeEvent<TEvents::TEvPong>(handle);
 
         ShutDown(s, SHUT_RDWR);
 
-        runtime.Send(new IEventHandle(wall, edge, new TEvents::TEvPing), 0, true);
+        runtime.Send(new IEventHandleFat(wall, edge, new TEvents::TEvPing), 0, true);
         runtime.GrabEdgeEvent<TEvents::TEvPong>(handle);
 
-        runtime.Send(new IEventHandle(session, edge, new TEvents::TEvPoisonPill));
+        runtime.Send(new IEventHandleFat(session, edge, new TEvents::TEvPoisonPill));
         runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeDisconnected>(handle);
         UNIT_ASSERT_EQUAL(handle->Sender, session);
     }
@@ -314,30 +315,30 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
 
         TAutoPtr<IEventHandle> handle;
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(1, 0), edge1, new TEvInterconnect::TEvConnectNode), 1, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(1, 0), edge1, new TEvInterconnect::TEvConnectNode), 1, true);
 
         {
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
             UNIT_ASSERT_EQUAL(event->NodeId, runtime.GetNodeId(0));
         }
 
-        runtime.Send(new IEventHandle(handle->Sender, edge0, new TEvents::TEvUnsubscribe), 1, true);
+        runtime.Send(new IEventHandleFat(handle->Sender, edge0, new TEvents::TEvUnsubscribe), 1, true);
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(1, 2), edge1, new TEvents::TEvSubscribe), 1, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(1, 2), edge1, new TEvents::TEvSubscribe), 1, true);
 
         {
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
             UNIT_ASSERT_EQUAL(event->NodeId, runtime.GetNodeId(2));
         }
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge0, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge0, new TEvInterconnect::TEvConnectNode), 0, true);
 
         {
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
             UNIT_ASSERT_EQUAL(event->NodeId, runtime.GetNodeId(1));
         }
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 2), edge0, new TEvents::TEvSubscribe), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 2), edge0, new TEvents::TEvSubscribe), 0, true);
 
         {
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
@@ -345,8 +346,8 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         }
 
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge0, new TEvents::TEvUnsubscribe), 0, true);
-        runtime.Send(new IEventHandle(handle->Sender, edge0, new TEvents::TEvPoisonPill));
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge0, new TEvents::TEvUnsubscribe), 0, true);
+        runtime.Send(new IEventHandleFat(handle->Sender, edge0, new TEvents::TEvPoisonPill));
 
         {
             const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeDisconnected>(handle);
@@ -369,12 +370,12 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         const auto edge = runtime.AllocateEdgeActor(0);
         const auto wall = runtime.Register(new TWall, 1);
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
 
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
 
-        runtime.Send(new IEventHandle(wall, edge, new TEvents::TEvPing), 0, true);
+        runtime.Send(new IEventHandleFat(wall, edge, new TEvents::TEvPing), 0, true);
         runtime.GrabEdgeEvent<TEvents::TEvPong>(handle);
 
         runtime.SetObserverFunc([&](TTestActorRuntimeBase&, TAutoPtr<IEventHandle>& ev){
@@ -401,7 +402,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                  TString::value_type(i);
 
         TAutoPtr<IEventHandle> ev =
-            new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, 69);
+            new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, 69);
         runtime.Send(ev.Release(), 0);
 
         TAutoPtr<IEventHandle> handle;
@@ -422,7 +423,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                  TString::value_type(i);
 
         TAutoPtr<IEventHandle> ev =
-            new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, 69);
+            new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, 69);
         TAutoPtr<IEventHandle> serev = GetSerialized(ev);
         runtime.Send(serev.Release(), 0);
 
@@ -444,7 +445,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                  const_cast<TString::value_type*>(blob.data())[i] =
                      '0' + (i % 10);
             TAutoPtr<IEventHandle> ev =
-                new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, s);
+                new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, s);
             runtime.Send(ev.Release(), 0);
             TAutoPtr<IEventHandle> handle;
             const auto event = runtime.GrabEdgeEvent<TEvents::TEvBlob>(handle);
@@ -465,7 +466,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                  const_cast<TString::value_type*>(blob.data())[i] =
                      '0' + (i % 10);
             TAutoPtr<IEventHandle> ev =
-                new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, s);
+                new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, s);
             TAutoPtr<IEventHandle> serev = GetSerialized(ev);
             runtime.Send(serev.Release(), 0);
             TAutoPtr<IEventHandle> handle;
@@ -487,7 +488,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                  const_cast<TString::value_type*>(blob.data())[i] =
                      '0' + (i % 10);
             TAutoPtr<IEventHandle> ev =
-                new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, s);
+                new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, s);
             TAutoPtr<IEventHandle> serev = GetSerialized(ev);
             TAutoPtr<IEventHandle> handle;
 
@@ -508,7 +509,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         runtime.Initialize(TAppPrepare().Unwrap());
         const auto edge = runtime.AllocateEdgeActor(0);
 
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1),
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1),
                                       edge,
                                       new TEvInterconnect::TEvConnectNode),
                      0, true);
@@ -516,7 +517,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
 
-        runtime.Send(new IEventHandle(TActorId(runtime.GetNodeId(1), "null"),
+        runtime.Send(new IEventHandleFat(TActorId(runtime.GetNodeId(1), "null"),
                                       edge,
                                       new TEvents::TEvPing,
                                       IEventHandle::FlagTrackDelivery, 13),
@@ -538,7 +539,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
             for (ui64 i = 0U; i < blob.size() / sizeof(ui64); ++i)
                  reinterpret_cast<ui64*>(const_cast<TString::value_type*>(blob.data()))[i] = i;
 
-            runtime.Send(new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, s), 0);
+            runtime.Send(new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, s), 0);
             TAutoPtr<IEventHandle> handle;
             const auto event = runtime.GrabEdgeEvent<TEvents::TEvBlob>(handle);
             UNIT_ASSERT_EQUAL(handle->Cookie, s);
@@ -559,7 +560,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                      const_cast<TString::value_type*>(blob.data()))[i] = i;
 
             TAutoPtr<IEventHandle> ev =
-                new IEventHandle(edge, edge, new TEvents::TEvBlob(blob), 0, s);
+                new IEventHandleFat(edge, edge, new TEvents::TEvBlob(blob), 0, s);
             TAutoPtr<IEventHandle> serev = GetSerialized(ev);
             runtime.Send(serev.Release(), 0, true);
             TAutoPtr<IEventHandle> handle;
@@ -575,7 +576,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         const auto edge = runtime.AllocateEdgeActor(0);
         const auto wall = runtime.Register(new TWall, 1);
 
-        runtime.Send(new IEventHandle(wall, edge, new TEvents::TEvPing, IEventHandle::FlagUseSubChannel, 113), 0);
+        runtime.Send(new IEventHandleFat(wall, edge, new TEvents::TEvPing, IEventHandle::FlagUseSubChannel, 113), 0);
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvents::TEvPong>(handle);
         UNIT_ASSERT_EQUAL(handle->Cookie, 113);
@@ -597,7 +598,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
 
             const auto src = runtime.AllocateEdgeActor(0);
 
-            runtime.Send(new IEventHandle(edge, src, new TEvents::TEvBlob(blob), IEventHandle::FlagUseSubChannel, i), 0);
+            runtime.Send(new IEventHandleFat(edge, src, new TEvents::TEvBlob(blob), IEventHandle::FlagUseSubChannel, i), 0);
 
             TAutoPtr<IEventHandle> handle;
             const auto event = runtime.GrabEdgeEvent<TEvents::TEvBlob>(handle);
@@ -621,7 +622,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
 
         auto sentTraceId = NWilson::TTraceId::NewTraceId(15, 4095);
 
-        runtime.Send(new IEventHandle(edge, edge,
+        runtime.Send(new IEventHandleFat(edge, edge,
                                       new TEvents::TEvBlob(blob),
                                       0, 13, nullptr, sentTraceId.Clone()),
                      0);
@@ -640,7 +641,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         auto event = new TEvResolveAddress;
         event->Address = "localhost";
         event->Port = 80;
-        runtime.Send(new IEventHandle(GetNameserviceActorId(), edge, event), 0);
+        runtime.Send(new IEventHandleFat(GetNameserviceActorId(), edge, event), 0);
         TAutoPtr<IEventHandle> handle;
         const auto reply = runtime.GrabEdgeEvent<TEvAddressInfo>(handle);
         UNIT_ASSERT_VALUES_EQUAL(NAddr::PrintHostAndPort(*reply->Address),
@@ -688,7 +689,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                     msg->Record.SetMeta(meta);
                     msg->Record.AddPayloadId(msg->AddPayload(TRope(rope1)));
                     msg->Record.AddPayloadId(msg->AddPayload(TRope(rope2)));
-                    runtime.Send(new IEventHandle(edge, TActorId(), msg.Release()), 0);
+                    runtime.Send(new IEventHandleFat(edge, TActorId(), msg.Release()), 0);
                 }
 
                 TAutoPtr<IEventHandle> handle;
@@ -718,7 +719,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
             Y_VERIFY(TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect, current)
                     .SerializeToString(&*common->CompatibilityInfo));
 
-            common->ValidateCompatibilityInfo = 
+            common->ValidateCompatibilityInfo =
                 [=](const TString& peer, TString& errorReason) {
                     NKikimrConfig::TStoredCompatibilityInfo peerPB;
                     if (!peerPB.ParseFromString(peer)) {
@@ -726,14 +727,14 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                         return false;
                     }
 
-                    return TCompatibilityInfo::CheckCompatibility(current, &peerPB, 
+                    return TCompatibilityInfo::CheckCompatibility(current, &peerPB,
                         (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
         });
         runtime.Initialize(TAppPrepare().Unwrap());
-        
+
         const auto edge = runtime.AllocateEdgeActor(0);
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
 
         TAutoPtr<IEventHandle> handle;
         {
@@ -743,7 +744,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
     }
 
     Y_UNIT_TEST(OldNbs) {
-        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node0 = 
+        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node0 =
             std::make_shared<NKikimrConfig::TCurrentCompatibilityInfo>();
         {
             node0->SetBuild("nbs");
@@ -754,7 +755,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
             version->SetHotfix(0);
         }
 
-        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node1 = 
+        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node1 =
             std::make_shared<NKikimrConfig::TCurrentCompatibilityInfo>();
         {
             node1->SetBuild("ydb");
@@ -782,9 +783,9 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         TestConnectionWithDifferentVersions(node0, node1);
         TestConnectionWithDifferentVersions(node1, node0);
     }
-    
+
     Y_UNIT_TEST(OldFormat) {
-        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node0 = 
+        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node0 =
             std::make_shared<NKikimrConfig::TCurrentCompatibilityInfo>();
         {
             node0->SetBuild("ydb");
@@ -814,7 +815,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
             if (nodeNum % 2 == 0) {
                 common->CompatibilityInfo = TString();
 
-                common->ValidateCompatibilityInfo = 
+                common->ValidateCompatibilityInfo =
                     [=](const TString& peer, TString& errorReason) {
                         NKikimrConfig::TStoredCompatibilityInfo peerPB;
                         if (!peerPB.ParseFromString(peer)) {
@@ -822,18 +823,18 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                             return false;
                         }
 
-                        return TCompatibilityInfo::CheckCompatibility(node0.get(), &peerPB, 
+                        return TCompatibilityInfo::CheckCompatibility(node0.get(), &peerPB,
                             (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                     };
 
-                common->ValidateCompatibilityOldFormat = 
+                common->ValidateCompatibilityOldFormat =
                     [=](const TMaybe<TInterconnectProxyCommon::TVersionInfo>& peer, TString& errorReason) {
                         if (!peer) {
                             return true;
                         }
-                        return TCompatibilityInfo::CheckCompatibility(node0.get(), *peer, 
+                        return TCompatibilityInfo::CheckCompatibility(node0.get(), *peer,
                             (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
-                    }; 
+                    };
             } else {
                 common->VersionInfo = TInterconnectProxyCommon::TVersionInfo{
                     .Tag = "stable-22-5-6-hotfix-1",
@@ -845,7 +846,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         runtime.Initialize(TAppPrepare().Unwrap());
 
         const auto edge = runtime.AllocateEdgeActor(0);
-        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
+        runtime.Send(new IEventHandleFat(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
 
         TAutoPtr<IEventHandle> handle;
         {
@@ -853,7 +854,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
             UNIT_ASSERT_EQUAL(event->NodeId, runtime.GetNodeId(1));
         }
     }
-    
+
 }
 
 }
diff --git a/ydb/core/actorlib_impl/test_protocols_ut.cpp b/ydb/core/actorlib_impl/test_protocols_ut.cpp
index c52132b32bd..d206a7100de 100644
--- a/ydb/core/actorlib_impl/test_protocols_ut.cpp
+++ b/ydb/core/actorlib_impl/test_protocols_ut.cpp
@@ -715,7 +715,7 @@ Y_UNIT_TEST_SUITE(TestProtocols) {
         msg->Data = writeData;
         msg->Len = strlen(writeData);
         msg->Last = false;
-        runtime.Send(new IEventHandle(testerId, tester->Edge, msg), 0);
+        runtime.Send(new IEventHandleFat(testerId, tester->Edge, msg), 0);
 
         runtime.GrabEdgeEvent<TEvHTTPStreamStatus>(handle);
 
@@ -728,7 +728,7 @@ Y_UNIT_TEST_SUITE(TestProtocols) {
         msg->Data = moreData;
         msg->Len = strlen(moreData);
         msg->Last = true;
-        runtime.Send(new IEventHandle(testerId, tester->Edge, msg), 0);
+        runtime.Send(new IEventHandleFat(testerId, tester->Edge, msg), 0);
 
         runtime.GrabEdgeEvent<TEvents::TEvWakeup>(handle);
     }
diff --git a/ydb/core/audit/audit_log_impl.cpp b/ydb/core/audit/audit_log_impl.cpp
index a8eae22d9e1..3a17664d0ca 100644
--- a/ydb/core/audit/audit_log_impl.cpp
+++ b/ydb/core/audit/audit_log_impl.cpp
@@ -93,7 +93,7 @@ void TAuditLogActor::HandleUnexpectedEvent(STFUNC_SIG)
 
     LOG_W("TAuditLogActor:"
           << " unhandled event type: " << ev->GetTypeRewrite()
-          << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+          << " event: " << ev->GetTypeName());
 }
 
 }    // namespace NKikimr::NAudit
diff --git a/ydb/core/base/blobstorage.h b/ydb/core/base/blobstorage.h
index 42e27b391f2..936529b7ace 100644
--- a/ydb/core/base/blobstorage.h
+++ b/ydb/core/base/blobstorage.h
@@ -424,7 +424,7 @@ inline IEventHandle *CreateEventForBSProxy(TActorId sender, TActorId recipient,
     std::unique_ptr<IEventBase> ptr(ev);
     const ui32 flags = NActors::IEventHandle::FlagTrackDelivery | NActors::IEventHandle::FlagForwardOnNondelivery;
     const TActorId nw = MakeBlobStorageNodeWardenID(sender.NodeId());
-    auto *res = new IEventHandle(recipient, sender, ptr.get(), flags, cookie, &nw, std::move(traceId));
+    auto *res = new IEventHandleFat(recipient, sender, ptr.get(), flags, cookie, &nw, std::move(traceId));
     ptr.release();
     return res;
 }
diff --git a/ydb/core/base/board_publish.cpp b/ydb/core/base/board_publish.cpp
index 8df046a9f48..767ffc85624 100644
--- a/ydb/core/base/board_publish.cpp
+++ b/ydb/core/base/board_publish.cpp
@@ -141,8 +141,8 @@ class TBoardPublishActor : public TActorBootstrapped<TBoardPublishActor> {
         if (ResolveGone(ev)) {
             const TActorId proxyId = MakeStateStorageProxyID(StateStorageGroupId);
             const ui32 flags = IEventHandle::FlagTrackDelivery;
-            TAutoPtr<IEventHandle> x = new IEventHandle(proxyId, SelfId(), new TEvStateStorage::TEvResolveBoard(Path), flags);
-            TActivationContext::Schedule(TDuration::MilliSeconds(50), x);
+            TAutoPtr<IEventHandle> x = new IEventHandleFat(proxyId, SelfId(), new TEvStateStorage::TEvResolveBoard(Path), flags);
+            TActivationContext::Schedule(TDuration::MilliSeconds(50), x.Release());
 
             Become(&TThis::StateResolve);
         }
diff --git a/ydb/core/base/statestorage_guardian.cpp b/ydb/core/base/statestorage_guardian.cpp
index cb06cb39b97..0880dcbc8bc 100644
--- a/ydb/core/base/statestorage_guardian.cpp
+++ b/ydb/core/base/statestorage_guardian.cpp
@@ -528,7 +528,7 @@ class TTabletGuardian : public TActorBootstrapped<TTabletGuardian> {
         } else {
             TActivationContext::Schedule(
                 delay,
-                new IEventHandle(proxyActorID, SelfId(), new TEvStateStorage::TEvResolveReplicas(tabletId), IEventHandle::FlagTrackDelivery)
+                new IEventHandleFat(proxyActorID, SelfId(), new TEvStateStorage::TEvResolveReplicas(tabletId), IEventHandle::FlagTrackDelivery)
             );
         }
 
diff --git a/ydb/core/base/statestorage_proxy.cpp b/ydb/core/base/statestorage_proxy.cpp
index 38fc1661dc8..3a2c0b94b0a 100644
--- a/ydb/core/base/statestorage_proxy.cpp
+++ b/ydb/core/base/statestorage_proxy.cpp
@@ -540,7 +540,7 @@ public:
                 BLOG_W("ProxyRequest::StateInit unexpected event type# "
                     << ev->GetTypeRewrite()
                     << " event: "
-                    << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                    << ev->ToString());
                 break;
         }
     }
@@ -558,7 +558,7 @@ public:
                 BLOG_W("ProxyRequest::StateLookup unexpected event type# "
                     << ev->GetTypeRewrite()
                     << " event: "
-                    << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                    << ev->ToString());
                 break;
         }
     }
@@ -575,7 +575,7 @@ public:
                 BLOG_W("ProxyRequest::StateUpdate unexpected event type# "
                     << ev->GetTypeRewrite()
                     << " event: "
-                    << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                    << ev->ToString());
                 break;
         }
     }
@@ -592,7 +592,7 @@ public:
                 BLOG_W("ProxyRequest::StateUpdateSig unexpected event type# "
                     << ev->GetTypeRewrite()
                     << " event: "
-                    << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                    << ev->ToString());
                 break;
         }
     }
@@ -971,7 +971,7 @@ public:
 
     STATEFN(StateInit) {
         BLOG_TRACE("Proxy::StateInit ev type# " << ev->GetTypeRewrite() << " event: "
-            << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+            << ev->ToString());
 
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvStateStorage::TEvRequestReplicasDumps, Handle);
@@ -986,7 +986,7 @@ public:
             hFunc(TEvStateStorage::TEvReplicaProbeSubscribe, Handle);
             hFunc(TEvStateStorage::TEvReplicaProbeUnsubscribe, Handle);
         default:
-            TActivationContext::Send(ev->Forward(RegisterWithSameMailbox(new TStateStorageProxyRequest(Info, FlowControlledInfo))));
+            TActivationContext::Forward(ev, RegisterWithSameMailbox(new TStateStorageProxyRequest(Info, FlowControlledInfo)));
             break;
         }
     }
@@ -1021,7 +1021,7 @@ public:
                 BLOG_W("ProxyStub::StateFunc unexpected event type# "
                     << ev->GetTypeRewrite()
                     << " event: "
-                    << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                    << ev->ToString());
                 break;
         }
     }
diff --git a/ydb/core/base/statestorage_replica.cpp b/ydb/core/base/statestorage_replica.cpp
index aca41acb16a..7ea4275373a 100644
--- a/ydb/core/base/statestorage_replica.cpp
+++ b/ydb/core/base/statestorage_replica.cpp
@@ -447,7 +447,7 @@ public:
 
             default:
                 BLOG_W("Replica::StateInit unexpected event type# " << ev->GetTypeRewrite()
-                    << " event: " << ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                    << " event: " << ev->ToString());
                 break;
         }
     }
diff --git a/ydb/core/base/tablet_pipe.h b/ydb/core/base/tablet_pipe.h
index 8eb63331a4e..146067a283a 100644
--- a/ydb/core/base/tablet_pipe.h
+++ b/ydb/core/base/tablet_pipe.h
@@ -225,7 +225,7 @@ namespace NKikimr {
             TEvClientCheckDelay() {}
         };
 
-        class TEvMessage : public TEventLocal<TEvMessage, EvMessage> {
+        class TEvMessage : public TEventLight<TEvMessage, EvMessage> {
         public:
             TEvMessage(const TActorId& sender, THolder<IEventBase> event)
                 : Type(event->Type())
diff --git a/ydb/core/base/tablet_resolver.h b/ydb/core/base/tablet_resolver.h
index 24744cef478..d297aa1d4b8 100644
--- a/ydb/core/base/tablet_resolver.h
+++ b/ydb/core/base/tablet_resolver.h
@@ -119,7 +119,7 @@ struct TEvTabletResolver {
         TString ToString() const {
             TStringStream str;
             str << "{EvForward TabletID: " << TabletID;
-            str << " Ev: " << (Ev ? Ev->GetBase()->ToString().data() : "nullptr");
+            str << " Ev: " << (Ev ? Ev->ToString() : "nullptr");
             str << " Flags: " << ResolveFlags.ToString();
             str << "}";
             return str.Str();
diff --git a/ydb/core/blob_depot/agent.cpp b/ydb/core/blob_depot/agent.cpp
index 5e59be28a0f..6eea54fbb22 100644
--- a/ydb/core/blob_depot/agent.cpp
+++ b/ydb/core/blob_depot/agent.cpp
@@ -106,7 +106,7 @@ namespace NKikimr::NBlobDepot {
                 blockActorsPending.push_back(actorId);
             }
 
-            auto r = std::make_unique<IEventHandle>(ev->Sender, ev->Recipient, reply.release(), 0, id);
+            auto r = std::make_unique<IEventHandleFat>(ev->Sender, ev->Recipient, reply.release(), 0, id);
             if (ev->InterconnectSession) {
                 r->Rewrite(TEvInterconnect::EvForward, ev->InterconnectSession);
             }
@@ -117,7 +117,7 @@ namespace NKikimr::NBlobDepot {
                 for (const TActorId& actorId : m) {
                     auto clone = std::make_unique<TEvBlobDepot::TEvPushNotifyResult>();
                     clone->Record.CopyFrom(ev->Get()->Record);
-                    TActivationContext::Send(new IEventHandle(actorId, sender, clone.release()));
+                    TActivationContext::Send(new IEventHandleFat(actorId, sender, clone.release()));
                 }
                 Data->OnPushNotifyResult(ev);
             });
@@ -229,7 +229,7 @@ namespace NKikimr::NBlobDepot {
                     for (auto& ev : std::exchange(info.PostponeQ, {})) {
                         TActivationContext::Send(ev.release());
                     }
-                    TActivationContext::Send(new IEventHandle(TEvPrivate::EvProcessRegisterAgentQ, 0, SelfId(), {}, nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(TEvPrivate::EvProcessRegisterAgentQ, 0, SelfId(), {}, nullptr, 0));
                 }
             }
         }
diff --git a/ydb/core/blob_depot/agent/agent_impl.h b/ydb/core/blob_depot/agent/agent_impl.h
index ebb975bf883..33d559a150a 100644
--- a/ydb/core/blob_depot/agent/agent_impl.h
+++ b/ydb/core/blob_depot/agent/agent_impl.h
@@ -239,7 +239,7 @@ namespace NKikimr::NBlobDepot {
                 }
                 if (!info->GetTotalVDisksNum()) {
                     // proxy finishes serving user requests
-                    TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, ProxyId, {}, nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, ProxyId, {}, nullptr, 0));
                     ProxyId = {};
                 }
             }
@@ -263,10 +263,10 @@ namespace NKikimr::NBlobDepot {
             std::shared_ptr<TEvBlobStorage::TExecutionRelay> executionRelay = nullptr);
 
         template<typename TEvent>
-        void HandleTabletResponse(TAutoPtr<TEventHandle<TEvent>> ev);
+        void HandleTabletResponse(TAutoPtr<TEventHandleFat<TEvent>> ev);
 
         template<typename TEvent>
-        void HandleOtherResponse(TAutoPtr<TEventHandle<TEvent>> ev);
+        void HandleOtherResponse(TAutoPtr<TEventHandleFat<TEvent>> ev);
 
         void OnRequestComplete(ui64 id, TRequestSender::TResponse response, TRequestsInFlight& map,
             std::shared_ptr<TEvBlobStorage::TExecutionRelay> executionRelay = nullptr);
diff --git a/ydb/core/blob_depot/agent/metrics.cpp b/ydb/core/blob_depot/agent/metrics.cpp
index 30ffff5330d..6440146e922 100644
--- a/ydb/core/blob_depot/agent/metrics.cpp
+++ b/ydb/core/blob_depot/agent/metrics.cpp
@@ -9,7 +9,7 @@ namespace NKikimr::NBlobDepot {
             NTabletPipe::SendData(SelfId(), PipeId, new TEvBlobDepot::TEvPushMetrics(bytesRead, bytesWritten));
         }
 
-        TActivationContext::Schedule(TDuration::MilliSeconds(2500), new IEventHandle(TEvPrivate::EvPushMetrics, 0, SelfId(),
+        TActivationContext::Schedule(TDuration::MilliSeconds(2500), new IEventHandleFat(TEvPrivate::EvPushMetrics, 0, SelfId(),
             {}, nullptr, 0));
     }
 
diff --git a/ydb/core/blob_depot/agent/query.cpp b/ydb/core/blob_depot/agent/query.cpp
index 0ab4456ca00..6ea304c0d15 100644
--- a/ydb/core/blob_depot/agent/query.cpp
+++ b/ydb/core/blob_depot/agent/query.cpp
@@ -29,7 +29,7 @@ namespace NKikimr::NBlobDepot {
 
         if (doForward) {
             if (ProxyId) {
-                TActivationContext::Send(ev->Forward(ProxyId));
+                TActivationContext::Forward(ev, ProxyId);
             } else {
                 CreateQuery<0>(std::unique_ptr<IEventHandle>(ev.Release()))->EndWithError(NKikimrProto::ERROR, "proxy has vanished");
             }
@@ -62,7 +62,7 @@ namespace NKikimr::NBlobDepot {
     }
 
     void TBlobDepotAgent::HandleAssimilate(TAutoPtr<IEventHandle> ev) {
-        TActivationContext::Send(ev->Forward(ProxyId));
+        TActivationContext::Forward(ev, ProxyId);
     }
 
     void TBlobDepotAgent::HandlePendingEvent() {
@@ -74,7 +74,7 @@ namespace NKikimr::NBlobDepot {
             PendingEventQ.pop_front();
             if (!PendingEventQ.empty() && TDuration::Seconds(timer.Passed()) >= TDuration::MilliSeconds(1)) {
                 if (!ProcessPendingEventInFlight) {
-                    TActivationContext::Send(new IEventHandle(TEvPrivate::EvProcessPendingEvent, 0, SelfId(), {}, nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(TEvPrivate::EvProcessPendingEvent, 0, SelfId(), {}, nullptr, 0));
                     ProcessPendingEventInFlight = true;
                 }
                 break;
@@ -118,7 +118,7 @@ namespace NKikimr::NBlobDepot {
             PendingEventQ.erase(PendingEventQ.begin(), it);
         }
 
-        TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(TEvPrivate::EvPendingEventQueueWatchdog, 0,
+        TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(TEvPrivate::EvPendingEventQueueWatchdog, 0,
             SelfId(), {}, nullptr, 0));
     }
 
@@ -136,7 +136,7 @@ namespace NKikimr::NBlobDepot {
                 break;
             }
         }
-        TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(TEvPrivate::EvQueryWatchdog, 0, SelfId(),
+        TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(TEvPrivate::EvQueryWatchdog, 0, SelfId(),
             {}, nullptr, 0));
     }
 
diff --git a/ydb/core/blob_depot/agent/request.cpp b/ydb/core/blob_depot/agent/request.cpp
index 621d5be545d..a944b8a5650 100644
--- a/ydb/core/blob_depot/agent/request.cpp
+++ b/ydb/core/blob_depot/agent/request.cpp
@@ -80,7 +80,7 @@ namespace NKikimr::NBlobDepot {
     }
 
     template<typename TEvent>
-    void TBlobDepotAgent::HandleTabletResponse(TAutoPtr<TEventHandle<TEvent>> ev) {
+    void TBlobDepotAgent::HandleTabletResponse(TAutoPtr<TEventHandleFat<TEvent>> ev) {
         STLOG(PRI_DEBUG, BLOB_DEPOT_AGENT, BDA16, "HandleTabletResponse", (AgentId, LogId),
             (Id, ev->Cookie), (Type, TypeName<TEvent>()), (Sender, ev->Sender), (PipeServerId, PipeServerId),
             (Match, ev->Sender == PipeServerId));
@@ -99,7 +99,7 @@ namespace NKikimr::NBlobDepot {
     template void TBlobDepotAgent::HandleTabletResponse(TEvBlobDepot::TEvResolveResult::TPtr ev);
 
     template<typename TEvent>
-    void TBlobDepotAgent::HandleOtherResponse(TAutoPtr<TEventHandle<TEvent>> ev) {
+    void TBlobDepotAgent::HandleOtherResponse(TAutoPtr<TEventHandleFat<TEvent>> ev) {
         STLOG(PRI_DEBUG, BLOB_DEPOT_AGENT, BDA17, "HandleOtherResponse", (AgentId, LogId), (Id, ev->Cookie),
             (Type, TypeName<TEvent>()), (Msg, *ev->Get()));
         Y_VERIFY(ev->Get()->ExecutionRelay);
diff --git a/ydb/core/blob_depot/assimilator.cpp b/ydb/core/blob_depot/assimilator.cpp
index 850b94c8f9e..492ae9be5f3 100644
--- a/ydb/core/blob_depot/assimilator.cpp
+++ b/ydb/core/blob_depot/assimilator.cpp
@@ -66,7 +66,7 @@ namespace NKikimr::NBlobDepot {
                 }
             }
             Self->Data->CommitTrash(this);
-            TActivationContext::Send(new IEventHandle(NotifyEventType, 0, ParentId, {}, nullptr, Cookie));
+            TActivationContext::Send(new IEventHandleFat(NotifyEventType, 0, ParentId, {}, nullptr, Cookie));
         }
     };
 
@@ -323,7 +323,7 @@ namespace NKikimr::NBlobDepot {
 
             if (timeout) { // timeout hit, reschedule work
                 if (!ResumeScanDataForCopyingInFlight) {
-                    TActivationContext::Send(new IEventHandle(TEvPrivate::EvResumeScanDataForCopying, 0, SelfId(), {}, nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(TEvPrivate::EvResumeScanDataForCopying, 0, SelfId(), {}, nullptr, 0));
                     ResumeScanDataForCopyingInFlight = true;
                 }
                 break;
@@ -514,7 +514,7 @@ namespace NKikimr::NBlobDepot {
             PassAway();
         } else {
             NTabletPipe::CloseAndForgetClient(SelfId(), PipeId);
-            TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandle(TEvPrivate::EvResume, 0, SelfId(), {}, nullptr, 0));
+            TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandleFat(TEvPrivate::EvResume, 0, SelfId(), {}, nullptr, 0));
         }
     }
 
diff --git a/ydb/core/blob_depot/blob_depot.cpp b/ydb/core/blob_depot/blob_depot.cpp
index 60aa159111e..68750df2e90 100644
--- a/ydb/core/blob_depot/blob_depot.cpp
+++ b/ydb/core/blob_depot/blob_depot.cpp
@@ -118,7 +118,7 @@ namespace NKikimr::NBlobDepot {
     void TBlobDepot::PassAway() {
         for (const TActorId& actorId : {GroupAssimilatorId}) {
             if (actorId) {
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
             }
         }
 
diff --git a/ydb/core/blob_depot/blocks.cpp b/ydb/core/blob_depot/blocks.cpp
index 001d5890eb8..9c34f3313d1 100644
--- a/ydb/core/blob_depot/blocks.cpp
+++ b/ydb/core/blob_depot/blocks.cpp
@@ -134,7 +134,7 @@ namespace NKikimr::NBlobDepot {
 
                     // add node to wait list; also start timer to remove this node from the wait queue
                     NodesWaitingForPushResult.insert(agentId);
-                    TActivationContext::Schedule(info.ExpirationTimestamp, new IEventHandle(TEvPrivate::EvCheckWaitingNode,
+                    TActivationContext::Schedule(info.ExpirationTimestamp, new IEventHandleFat(TEvPrivate::EvCheckWaitingNode,
                         0, SelfId(), {}, nullptr, agentId));
 
                     // issue message to the connected node, if it is
@@ -149,7 +149,7 @@ namespace NKikimr::NBlobDepot {
                         agent.PushCallbacks.emplace(id, [selfId = SelfId()](TEvBlobDepot::TEvPushNotifyResult::TPtr ev) {
                             TActivationContext::Send(ev->Forward(selfId));
                         });
-                        TActivationContext::Send(new IEventHandle(connection->AgentId, connection->PipeServerId, ev.release(), 0, id));
+                        TActivationContext::Send(new IEventHandleFat(connection->AgentId, connection->PipeServerId, ev.release(), 0, id));
                     }
                 }
             }
@@ -161,7 +161,7 @@ namespace NKikimr::NBlobDepot {
                 const TMonotonic now = TActivationContext::Monotonic();
                 const auto& info = Self->BlocksManager->Blocks[TabletId].PerAgentInfo[agentId];
                 if (now < info.ExpirationTimestamp) { // node still can write data for this tablet, reschedule timer
-                    TActivationContext::Schedule(info.ExpirationTimestamp, new IEventHandle(TEvPrivate::EvCheckWaitingNode,
+                    TActivationContext::Schedule(info.ExpirationTimestamp, new IEventHandleFat(TEvPrivate::EvCheckWaitingNode,
                         0, SelfId(), {}, nullptr, agentId));
                 } else {
                     NodesWaitingForPushResult.erase(agentId);
diff --git a/ydb/core/blob_depot/data.cpp b/ydb/core/blob_depot/data.cpp
index 5251191bd47..7d55180915d 100644
--- a/ydb/core/blob_depot/data.cpp
+++ b/ydb/core/blob_depot/data.cpp
@@ -269,7 +269,7 @@ namespace NKikimr::NBlobDepot {
         value.UncertainWrite = false;
         KeysMadeCertain.push_back(key);
         if (!CommitCertainKeysScheduled) {
-            TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(TEvPrivate::EvCommitCertainKeys, 0,
+            TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(TEvPrivate::EvCommitCertainKeys, 0,
                 Self->SelfId(), {}, nullptr, 0));
             CommitCertainKeysScheduled = true;
         }
@@ -304,7 +304,7 @@ namespace NKikimr::NBlobDepot {
                 if (Self->Data->KeysMadeCertain.empty()) {
                     Self->Data->CommitCertainKeysScheduled = false;
                 } else {
-                    TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(TEvPrivate::EvCommitCertainKeys,
+                    TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(TEvPrivate::EvCommitCertainKeys,
                         0, Self->SelfId(), {}, nullptr, 0));
                 }
             }
diff --git a/ydb/core/blob_depot/data_resolve.cpp b/ydb/core/blob_depot/data_resolve.cpp
index 233924a275d..60b0ecfe381 100644
--- a/ydb/core/blob_depot/data_resolve.cpp
+++ b/ydb/core/blob_depot/data_resolve.cpp
@@ -7,7 +7,7 @@ namespace NKikimr::NBlobDepot {
 
     using TData = TBlobDepot::TData;
 
-    TData::TResolveResultAccumulator::TResolveResultAccumulator(TEventHandle<TEvBlobDepot::TEvResolve>& ev)
+    TData::TResolveResultAccumulator::TResolveResultAccumulator(TEventHandleFat<TEvBlobDepot::TEvResolve>& ev)
         : Sender(ev.Sender)
         , Recipient(ev.Recipient)
         , Cookie(ev.Cookie)
@@ -23,7 +23,7 @@ namespace NKikimr::NBlobDepot {
 
     void TData::TResolveResultAccumulator::Send(NKikimrProto::EReplyStatus status, std::optional<TString> errorReason) {
         auto sendResult = [&](std::unique_ptr<TEvBlobDepot::TEvResolveResult> ev) {
-            auto handle = std::make_unique<IEventHandle>(Sender, Recipient, ev.release(), 0, Cookie);
+            auto handle = std::make_unique<IEventHandleFat>(Sender, Recipient, ev.release(), 0, Cookie);
             if (InterconnectSession) {
                 handle->Rewrite(TEvInterconnect::EvForward, InterconnectSession);
             }
diff --git a/ydb/core/blob_depot/data_resolve.h b/ydb/core/blob_depot/data_resolve.h
index bf66c2bfb3a..b35295160eb 100644
--- a/ydb/core/blob_depot/data_resolve.h
+++ b/ydb/core/blob_depot/data_resolve.h
@@ -14,7 +14,7 @@ namespace NKikimr::NBlobDepot {
         std::vector<bool> KeysToFilterOut;
 
     public:
-        TResolveResultAccumulator(TEventHandle<TEvBlobDepot::TEvResolve>& ev);
+        TResolveResultAccumulator(TEventHandleFat<TEvBlobDepot::TEvResolve>& ev);
 
         void AddItem(NKikimrBlobDepot::TEvResolveResult::TResolvedKey&& item, const NKikimrBlobDepot::TBlobDepotConfig& config);
         void Send(NKikimrProto::EReplyStatus status, std::optional<TString> errorReason);
diff --git a/ydb/core/blob_depot/data_trash.cpp b/ydb/core/blob_depot/data_trash.cpp
index 1e41c0df710..b45bb1b7455 100644
--- a/ydb/core/blob_depot/data_trash.cpp
+++ b/ydb/core/blob_depot/data_trash.cpp
@@ -72,7 +72,7 @@ namespace NKikimr::NBlobDepot {
                     }
                 }
             }
-            
+
             // adjust the barrier to keep it safe now (till we trim ids)
             const TLogoBlobID maxId(Self->TabletID(), leastExpectedBlobId.Generation,
                 leastExpectedBlobId.Step, record.Channel, 0, 0);
@@ -173,7 +173,7 @@ namespace NKikimr::NBlobDepot {
 
             Y_VERIFY(agent.Connection);
             agent.PushCallbacks.emplace(id, std::bind(&TData::OnPushNotifyResult, this, std::placeholders::_1));
-            TActivationContext::Send(new IEventHandle(agent.Connection->AgentId, agent.Connection->PipeServerId, ev.release(), 0, id));
+            TActivationContext::Send(new IEventHandleFat(agent.Connection->AgentId, agent.Connection->PipeServerId, ev.release(), 0, id));
         }
     }
 
diff --git a/ydb/core/blob_depot/events.h b/ydb/core/blob_depot/events.h
index 5f19c5dac05..e78bb397059 100644
--- a/ydb/core/blob_depot/events.h
+++ b/ydb/core/blob_depot/events.h
@@ -87,10 +87,10 @@ namespace NKikimr {
         template<> struct TResponseFor<TEvResolve>        { using Type = TEvResolveResult; };
 
         template<typename TRequestEvent, typename... TArgs>
-        static auto MakeResponseFor(TEventHandle<TRequestEvent>& ev, TArgs&&... args) {
+        static auto MakeResponseFor(TEventHandleFat<TRequestEvent>& ev, TArgs&&... args) {
             auto event = std::make_unique<typename TResponseFor<TRequestEvent>::Type>(std::forward<TArgs>(args)...);
             auto *record = &event->Record;
-            auto handle = std::make_unique<IEventHandle>(ev.Sender, ev.Recipient, event.release(), 0, ev.Cookie);
+            auto handle = std::make_unique<IEventHandleFat>(ev.Sender, ev.Recipient, event.release(), 0, ev.Cookie);
             if (ev.InterconnectSession) {
                 handle->Rewrite(TEvInterconnect::EvForward, ev.InterconnectSession);
             }
diff --git a/ydb/core/blob_depot/group_metrics_exchange.cpp b/ydb/core/blob_depot/group_metrics_exchange.cpp
index 052e5833954..bc00f92c543 100644
--- a/ydb/core/blob_depot/group_metrics_exchange.cpp
+++ b/ydb/core/blob_depot/group_metrics_exchange.cpp
@@ -20,7 +20,7 @@ namespace NKikimr::NBlobDepot {
         }
 
         Send(MakeBlobStorageNodeWardenID(SelfId().NodeId()), ev.release());
-        TActivationContext::Schedule(TDuration::Seconds(10), new IEventHandle(TEvPrivate::EvDoGroupMetricsExchange, 0,
+        TActivationContext::Schedule(TDuration::Seconds(10), new IEventHandleFat(TEvPrivate::EvDoGroupMetricsExchange, 0,
             SelfId(), {}, nullptr, 0));
     }
 
@@ -145,7 +145,7 @@ namespace NKikimr::NBlobDepot {
         }
 
         if (reschedule) {
-            TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(TEvPrivate::EvUpdateThroughputs, 0,
+            TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(TEvPrivate::EvUpdateThroughputs, 0,
                 SelfId(), {}, nullptr, 0));
         }
     }
diff --git a/ydb/core/blob_depot/mon_main.cpp b/ydb/core/blob_depot/mon_main.cpp
index 9cb2cf2d60e..8d35aef51f6 100644
--- a/ydb/core/blob_depot/mon_main.cpp
+++ b/ydb/core/blob_depot/mon_main.cpp
@@ -364,11 +364,11 @@ namespace NKikimr::NBlobDepot {
         }
 
         void Complete(const TActorContext&) override {
-            TActivationContext::Send(new IEventHandle(Request->Sender, Self->SelfId(), new NMon::TEvRemoteHttpInfoRes(
+            TActivationContext::Send(new IEventHandleFat(Request->Sender, Self->SelfId(), new NMon::TEvRemoteHttpInfoRes(
                 Stream.Str()), 0, Request->Cookie));
         }
     };
-    
+
     bool TBlobDepot::OnRenderAppHtmlPage(NMon::TEvRemoteHttpInfo::TPtr ev, const TActorContext&) {
         if (!Executor() || !Executor()->GetStats().IsActive) {
             return false;
diff --git a/ydb/core/blob_depot/op_apply_config.cpp b/ydb/core/blob_depot/op_apply_config.cpp
index 2672108e463..d16c6274e29 100644
--- a/ydb/core/blob_depot/op_apply_config.cpp
+++ b/ydb/core/blob_depot/op_apply_config.cpp
@@ -57,7 +57,7 @@ namespace NKikimr::NBlobDepot {
         };
 
         auto responseEvent = std::make_unique<TEvBlobDepot::TEvApplyConfigResult>(TabletID(), ev->Get()->Record.GetTxId());
-        auto response = std::make_unique<IEventHandle>(ev->Sender, SelfId(), responseEvent.release(), 0, ev->Cookie);
+        auto response = std::make_unique<IEventHandleFat>(ev->Sender, SelfId(), responseEvent.release(), 0, ev->Cookie);
         Execute(std::make_unique<TTxApplyConfig>(this, *ev->Get(), std::move(response), ev->InterconnectSession));
     }
 
diff --git a/ydb/core/blob_depot/space_monitor.cpp b/ydb/core/blob_depot/space_monitor.cpp
index 033fdcd6594..ea3a21165c4 100644
--- a/ydb/core/blob_depot/space_monitor.cpp
+++ b/ydb/core/blob_depot/space_monitor.cpp
@@ -60,7 +60,7 @@ namespace NKikimr::NBlobDepot {
             }
         }
 
-        TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandle(TEvPrivate::EvKickSpaceMonitor, 0,
+        TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandleFat(TEvPrivate::EvKickSpaceMonitor, 0,
             Self->SelfId(), {}, nullptr, 0));
     }
 
diff --git a/ydb/core/blobstorage/backpressure/event.cpp b/ydb/core/blobstorage/backpressure/event.cpp
index d807d5fe953..275366f0bad 100644
--- a/ydb/core/blobstorage/backpressure/event.cpp
+++ b/ydb/core/blobstorage/backpressure/event.cpp
@@ -74,7 +74,7 @@ void TEventHolder::SendToVDisk(const TActorContext& ctx, const TActorId& remoteV
         Y_VERIFY(status);
 
         // send it to disk
-        ctx.ExecutorThread.Send(new IEventHandle(Type, flags, remoteVDisk, ctx.SelfID,
+        ctx.ExecutorThread.Send(new IEventHandleFat(Type, flags, remoteVDisk, ctx.SelfID,
             MakeIntrusive<TEventSerializedData>(*Buffer, std::move(buf)), queueCookie, nullptr, std::move(traceId)));
     }
 }
diff --git a/ydb/core/blobstorage/backpressure/queue.h b/ydb/core/blobstorage/backpressure/queue.h
index a855eef33c9..55aaba2066b 100644
--- a/ydb/core/blobstorage/backpressure/queue.h
+++ b/ydb/core/blobstorage/backpressure/queue.h
@@ -55,7 +55,7 @@ class TBlobStorageQueue {
         TTrackableList<TItem>::iterator Iterator;
 
         template<typename TEvent>
-        TItem(TAutoPtr<TEventHandle<TEvent>>& event, TInstant deadline,
+        TItem(TAutoPtr<TEventHandleFat<TEvent>>& event, TInstant deadline,
                 const ::NMonitoring::TDynamicCounters::TCounterPtr& serItems,
                 const ::NMonitoring::TDynamicCounters::TCounterPtr& serBytes,
                 const TBSProxyContextPtr& bspctx, ui32 interconnectChannel,
diff --git a/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp b/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp
index 63892dbe575..46551b1eafb 100644
--- a/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp
+++ b/ydb/core/blobstorage/backpressure/queue_backpressure_client_ut.cpp
@@ -38,7 +38,7 @@ public:
 
     template<typename TPtr>
     void HandleFw(TPtr& ev, const TActorContext& ctx) {
-        ctx.ExecutorThread.Send(new IEventHandle(VDiskId, ctx.SelfID, ev->Release().Release(), 0, ev->Cookie));
+        ctx.ExecutorThread.Send(new IEventHandleFat(VDiskId, ctx.SelfID, ev->Release().Release(), 0, ev->Cookie));
     }
 
     template<typename TPtr>
@@ -293,7 +293,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageQueueTest) {
         TVector<std::pair<ui64, ui64>> sequence;
         auto filterFunc = [&](IEventHandle& ev, const TActorContext& /*ctx*/) {
             if (ev.GetTypeRewrite() == TEvBlobStorage::TEvVGet::EventType) {
-                TEventHandle<TEvBlobStorage::TEvVGet>& evv = reinterpret_cast<TEventHandle<TEvBlobStorage::TEvVGet>&>(ev);
+                TEventHandleFat<TEvBlobStorage::TEvVGet>& evv = reinterpret_cast<TEventHandleFat<TEvBlobStorage::TEvVGet>&>(ev);
                 const auto& record = evv.Get()->Record;
                 const auto& msgQoS = record.GetMsgQoS();
                 const auto& id = msgQoS.GetMsgId();
@@ -317,7 +317,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageQueueTest) {
                                                                        TEvBlobStorage::TEvVGet::EFlags::None,
                                                                        {},
                                                                        {TLogoBlobID(1, 1, 1, 0, 10, i)});
-            runtime.Send(std::make_unique<IEventHandle>(runtime.GetQueueActorId(), runtime.GetProxyActorId(), req.release()));
+            runtime.Send(std::make_unique<IEventHandleFat>(runtime.GetQueueActorId(), runtime.GetProxyActorId(), req.release()));
         }
         runtime.WaitCompleted();
         runtime.Stop();
diff --git a/ydb/core/blobstorage/backpressure/ut_client/backpressure_ut.cpp b/ydb/core/blobstorage/backpressure/ut_client/backpressure_ut.cpp
index 1a0760c6cf9..78cd1b630ad 100644
--- a/ydb/core/blobstorage/backpressure/ut_client/backpressure_ut.cpp
+++ b/ydb/core/blobstorage/backpressure/ut_client/backpressure_ut.cpp
@@ -61,7 +61,7 @@ Y_UNIT_TEST_SUITE(Backpressure) {
 
                 case TERM_CLIENT: {
                     const size_t index = RandomNumber(clients.size());
-                    runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, clients[index], {}, {}, 0), 1);
+                    runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, clients[index], {}, {}, 0), 1);
                     clients.erase(clients.begin() + index);
                     break;
                 }
@@ -78,9 +78,9 @@ Y_UNIT_TEST_SUITE(Backpressure) {
 
         // terminate loader actors and the disk
         for (const TActorId& actorId : std::exchange(clients, {})) {
-            runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, {}, 0), 1);
+            runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, {}, {}, 0), 1);
         }
-        runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, vdiskActorId, {}, {}, 0), 1);
+        runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, vdiskActorId, {}, {}, 0), 1);
 
         runtime.Stop();
     }
diff --git a/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h b/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h
index 66805e3a1dd..f31e4255f6a 100644
--- a/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h
+++ b/ydb/core/blobstorage/backpressure/ut_client/skeleton_front_mock.h
@@ -110,7 +110,7 @@ public:
             if (Operations.empty()) {
                 Schedule(TDuration::MicroSeconds((999 + cost) / 1000), new TEvProcessQueue);
             }
-            Operations.push_back(TOperation{clientId, messageId, cost, std::make_unique<IEventHandle>(ev->Sender,
+            Operations.push_back(TOperation{clientId, messageId, cost, std::make_unique<IEventHandleFat>(ev->Sender,
                 SelfId(), reply.release(), IEventHandle::MakeFlags(ev->GetChannel(), 0), ev->Cookie), ev->Sender});
         } else {
             reply->Record.SetStatus(feedback.first.Status == NKikimrBlobStorage::TWindowFeedback::IncorrectMsgId
diff --git a/ydb/core/blobstorage/base/blobstorage_events.h b/ydb/core/blobstorage/base/blobstorage_events.h
index a6a330ee2aa..f4921e65d60 100644
--- a/ydb/core/blobstorage/base/blobstorage_events.h
+++ b/ydb/core/blobstorage/base/blobstorage_events.h
@@ -411,10 +411,9 @@ namespace NKikimr {
         std::vector<std::unique_ptr<IEventHandle>> Bunch;
 
         void Process(IActor *actor) {
-            const TActorContext& ctx = TActivationContext::AsActorContext();
             for (auto& ev : Bunch) {
                 TAutoPtr<IEventHandle> handle(ev.release());
-                actor->Receive(handle, ctx);
+                actor->Receive(handle);
             }
         }
     };
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy.h b/ydb/core/blobstorage/dsproxy/dsproxy.h
index 365f7950c9a..10ec5b104cd 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy.h
@@ -193,7 +193,7 @@ public:
 
     void Registered(TActorSystem *as, const TActorId& parentId) override {
         ProxyActorId = parentId;
-        as->Send(new IEventHandle(TEvents::TSystem::Bootstrap, 0,
+        as->Send(new IEventHandleFat(TEvents::TSystem::Bootstrap, 0,
             TActor<TBlobStorageGroupRequestActor<TDerived>>::SelfId(), parentId, nullptr, 0));
         TActor<TBlobStorageGroupRequestActor<TDerived>>::Registered(as, parentId);
     }
@@ -213,7 +213,7 @@ public:
     }
 
     template<typename TEvent>
-    bool CheckForTermErrors(TAutoPtr<TEventHandle<TEvent>>& ev) {
+    bool CheckForTermErrors(TAutoPtr<TEventHandleFat<TEvent>>& ev) {
         auto& record = ev->Get()->Record;
         auto& self = Derived();
 
@@ -306,7 +306,7 @@ public:
         }
         ++*Mon->NodeMon->RestartHisto[Min<size_t>(Mon->NodeMon->RestartHisto.size() - 1, RestartCounter)];
         const TActorId& proxyId = MakeBlobStorageProxyID(Info->GroupID);
-        TActivationContext::Send(new IEventHandle(nodeWardenId, Source, q.release(), 0, Cookie, &proxyId, Span.GetTraceId()));
+        TActivationContext::Send(new IEventHandleFat(nodeWardenId, Source, q.release(), 0, Cookie, &proxyId, Span.GetTraceId()));
         PassAway();
         return true;
     }
@@ -326,7 +326,7 @@ public:
 #undef CHECK
 
             case TEvBlobStorage::EvProxySessionsState: {
-                GroupQueues = static_cast<TEvProxySessionsState*>(ev->GetBase())->GroupQueues;
+                GroupQueues = ev->Get<TEvProxySessionsState>()->GroupQueues;
                 return true;
             }
 
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_impl.h b/ydb/core/blobstorage/dsproxy/dsproxy_impl.h
index 8e46ae6c369..266f6eb70f9 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_impl.h
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_impl.h
@@ -189,7 +189,7 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
     // Put to init queue
 
     template<typename TEvent>
-    void HandleEnqueue(TAutoPtr<TEventHandle<TEvent>> ev) {
+    void HandleEnqueue(TAutoPtr<TEventHandleFat<TEvent>> ev) {
         LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::BS_PROXY, "Group# " << GroupId
                 << " HandleEnqueue# " << ev->Get()->Print(false) << " Marker# DSP17");
         if constexpr (std::is_same_v<TEvent, TEvBlobStorage::TEvGet>) {
@@ -274,7 +274,7 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
     }
 
     template<typename TEvent>
-    void HandleError(TAutoPtr<TEventHandle<TEvent>> ev) {
+    void HandleError(TAutoPtr<TEventHandleFat<TEvent>> ev) {
         bool full = false;
         if constexpr (std::is_same_v<TEvent, TEvBlobStorage::TEvBlock> || std::is_same_v<TEvent, TEvBlobStorage::TEvCollectGarbage>) {
             full = ev->Get()->IsMonitored;
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp
index a9ce350f309..bda01f89f12 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_put.cpp
@@ -393,7 +393,7 @@ class TBlobStorageGroupPutRequest : public TBlobStorageGroupRequestActor<TBlobSt
             char* data = buffer.GetContiguousSpanMut().data();
             Decrypt(data, data, 0, buffer.size(), item.BlobId, *Info);
 
-            ev->Bunch.emplace_back(new IEventHandle(
+            ev->Bunch.emplace_back(new IEventHandleFat(
                 TActorId() /*recipient*/,
                 item.Recipient,
                 put = new TEvBlobStorage::TEvPut(item.BlobId, std::move(buffer), Deadline, HandleClass, Tactic),
diff --git a/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp b/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
index 01f7b966f06..3e3c55c6de4 100644
--- a/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
+++ b/ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
@@ -46,7 +46,7 @@ namespace NKikimr {
         Become(&TThis::StateEstablishingSessionsTimeout);
         ++*NodeMon->EstablishingSessionsTimeout;
         InEstablishingSessionsTimeout = true;
-        TActivationContext::Schedule(TDuration::Minutes(5), new IEventHandle(Ev5min, 0, SelfId(), {}, nullptr, ++Cookie5min));
+        TActivationContext::Schedule(TDuration::Minutes(5), new IEventHandleFat(Ev5min, 0, SelfId(), {}, nullptr, ++Cookie5min));
         ProcessInitQueue();
     }
 
@@ -69,7 +69,7 @@ namespace NKikimr {
         Become(&TThis::StateUnconfiguredTimeout);
         ++*NodeMon->UnconfiguredTimeout;
         InUnconfiguredTimeout = true;
-        TActivationContext::Schedule(TDuration::Minutes(5), new IEventHandle(Ev5min, 0, SelfId(), {}, nullptr, ++Cookie5min));
+        TActivationContext::Schedule(TDuration::Minutes(5), new IEventHandleFat(Ev5min, 0, SelfId(), {}, nullptr, ++Cookie5min));
         ProcessInitQueue();
     }
 
@@ -230,10 +230,10 @@ namespace NKikimr {
             }
             Become(&TThis::StateEjected);
         } else {
-            StopPutBatchingEvent = static_cast<TEventHandle<TEvStopBatchingPutRequests>*>(
-                    new IEventHandle(SelfId(), SelfId(), new TEvStopBatchingPutRequests));
-            StopGetBatchingEvent = static_cast<TEventHandle<TEvStopBatchingGetRequests>*>(
-                    new IEventHandle(SelfId(), SelfId(), new TEvStopBatchingGetRequests));
+            StopPutBatchingEvent = static_cast<TEventHandleFat<TEvStopBatchingPutRequests>*>(
+                    new IEventHandleFat(SelfId(), SelfId(), new TEvStopBatchingPutRequests));
+            StopGetBatchingEvent = static_cast<TEventHandleFat<TEvStopBatchingGetRequests>*>(
+                    new IEventHandleFat(SelfId(), SelfId(), new TEvStopBatchingGetRequests));
             ApplyGroupInfo(std::exchange(Info, {}), std::exchange(StoragePoolCounters, {}));
         }
     }
@@ -251,7 +251,7 @@ namespace NKikimr {
 
     void TBlobStorageGroupProxy::PassAway() {
         for (const TActorId actorId : ActiveRequests) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
         }
         if (Sessions) { // may be null if not properly configured yet
             Sessions->Poison();
@@ -276,7 +276,7 @@ namespace NKikimr {
         UnconfiguredBufferSize = 0;
         for (std::unique_ptr<IEventHandle>& ev : std::exchange(InitQueue, {})) {
             TAutoPtr<IEventHandle> x(ev.release());
-            Receive(x, TActivationContext::ActorContextFor(SelfId()));
+            Receive(x);
         }
     }
 
diff --git a/ydb/core/blobstorage/dsproxy/group_sessions.cpp b/ydb/core/blobstorage/dsproxy/group_sessions.cpp
index 36858c9cc1d..5b1ec45e953 100644
--- a/ydb/core/blobstorage/dsproxy/group_sessions.cpp
+++ b/ydb/core/blobstorage/dsproxy/group_sessions.cpp
@@ -94,7 +94,7 @@ void TGroupSessions::Poison() {
     for (const auto& domain : GroupQueues->FailDomains) {
         for (const auto& vdisk : domain.VDisks) {
             vdisk.Queues.ForEachQueue([](const auto& queue) {
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, queue.ActorId, {}, nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, queue.ActorId, {}, nullptr, 0));
             });
         }
     }
diff --git a/ydb/core/blobstorage/dsproxy/group_sessions.h b/ydb/core/blobstorage/dsproxy/group_sessions.h
index b5f33d2f4ed..5e506ff0211 100644
--- a/ydb/core/blobstorage/dsproxy/group_sessions.h
+++ b/ydb/core/blobstorage/dsproxy/group_sessions.h
@@ -196,7 +196,7 @@ namespace NKikimr {
             TActorId queueId = queues.QueueForEvent(*event);
             LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::BS_PROXY, "Send to queueId# " << queueId
                 << " " << TypeName<TEvent>() << "# " << event->ToString() << " cookie# " << cookie);
-            TActivationContext::Send(new IEventHandle(queueId, actor.SelfId(), event.release(), 0, cookie, nullptr, std::move(traceId)));
+            TActivationContext::Send(new IEventHandleFat(queueId, actor.SelfId(), event.release(), 0, cookie, nullptr, std::move(traceId)));
             return queueId;
         }
 
diff --git a/ydb/core/blobstorage/dsproxy/log_acc.h b/ydb/core/blobstorage/dsproxy/log_acc.h
index a5938d5fdf4..5c6cc9bbe4d 100644
--- a/ydb/core/blobstorage/dsproxy/log_acc.h
+++ b/ydb/core/blobstorage/dsproxy/log_acc.h
@@ -51,7 +51,7 @@ namespace NKikimr {
             }
             TActorId logger = loggerSettings->LoggerActorId;
             for (auto it = Lines.begin(); it != Lines.end(); ++it) {
-                TActivationContext::Send(new IEventHandle(logger, TActorId(), new ::NActors::NLog::TEvLog(it->Priority, it->Component, it->Formatted)));
+                TActivationContext::Send(new IEventHandleFat(logger, TActorId(), new ::NActors::NLog::TEvLog(it->Priority, it->Component, it->Formatted)));
             }
             Lines.clear();
         }
@@ -97,7 +97,7 @@ namespace NKikimr {
                     } \
                     TStringBuilder logStringBuilder; \
                     logStringBuilder << stream; \
-                    TActivationContext::Send(new IEventHandle(mSettings->LoggerActorId, TActorId(), \
+                    TActivationContext::Send(new IEventHandleFat(mSettings->LoggerActorId, TActorId(), \
                         new ::NActors::NLog::TEvLog(mPriority, mComponent, (TString)logStringBuilder)); \
                 } else { \
                     if (!(isRelease)) { \
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
index f196cc92561..7077b75c881 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
@@ -88,7 +88,7 @@ struct TDSProxyEnv {
 
         FakeProxyActorId = runtime.AllocateEdgeActor(0);
         TAutoPtr <IEventHandle> handle;
-        runtime.Send(new IEventHandle(RealProxyActorId, FakeProxyActorId, new TEvRequestProxySessionsState));
+        runtime.Send(new IEventHandleFat(RealProxyActorId, FakeProxyActorId, new TEvRequestProxySessionsState));
         auto queues = runtime.GrabEdgeEventRethrow<TEvProxySessionsState>(handle);
         GroupQueues = queues->GroupQueues;
         NodeLayoutInfo = nullptr;
@@ -150,7 +150,7 @@ inline void SetupRuntime(TTestActorRuntime& runtime) {
 
     runtime.SetEventFilter([](TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& ev) {
         if (ev->GetTypeRewrite() == TEvBlobStorage::EvVCheckReadiness) {
-            runtime.Send(new IEventHandle(
+            runtime.Send(new IEventHandleFat(
                     ev->Sender, ev->Recipient, new TEvBlobStorage::TEvVCheckReadinessResult(NKikimrProto::OK), 0,
                     ev->Cookie), 0, true);
             return true;
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp
index 151a316c2ce..78a433890d9 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_patch_ut.cpp
@@ -270,7 +270,7 @@ NKikimrProto::EReplyStatus GetVMovedPatchResultStatus(EMovedPatchCase movedCase)
 
 template <typename THandle, typename TEventHolder>
 void SendByHandle(TTestBasicRuntime &runtime, const THandle &oldHandle, TEventHolder &&ev) {
-    auto handle = std::make_unique<IEventHandle>(oldHandle->Sender, oldHandle->Recipient, ev.release(), oldHandle->Flags, oldHandle->Cookie);
+    auto handle = std::make_unique<IEventHandleFat>(oldHandle->Sender, oldHandle->Recipient, ev.release(), oldHandle->Flags, oldHandle->Cookie);
     runtime.Send(handle.release());
 }
 
@@ -520,8 +520,8 @@ TEvBlobStorage::TEvPatch::TPtr CreatePatch(TTestBasicRuntime &runtime, const TDS
     std::unique_ptr<TEvBlobStorage::TEvPatch> patch = std::make_unique<TEvBlobStorage::TEvPatch>(
             args.OriginalGroupId, args.OriginalId, args.PatchedId, args.MaskForCookieBruteForcing, std::move(diffs),
             args.Diffs.size(), deadline);
-    TEvBlobStorage::TEvPatch::TPtr ev(static_cast<TEventHandle<TEvBlobStorage::TEvPatch>*>(
-            new IEventHandle(env.FakeProxyActorId, env.FakeProxyActorId, patch.release())));
+    TEvBlobStorage::TEvPatch::TPtr ev(static_cast<TEventHandleFat<TEvBlobStorage::TEvPatch>*>(
+            new IEventHandleFat(env.FakeProxyActorId, env.FakeProxyActorId, patch.release())));
     return ev;
 }
 
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp
index e94b2c398d5..32751cc0d7e 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_put_ut.cpp
@@ -355,8 +355,8 @@ struct TTestPutAllOk {
             for (auto &blobId : BlobIds) {
                 std::unique_ptr<TEvBlobStorage::TEvPut> vPut(new TEvBlobStorage::TEvPut(blobId, Data, TInstant::Max(),
                         NKikimrBlobStorage::TabletLog, TEvBlobStorage::TEvPut::TacticDefault));
-                events.emplace_back(static_cast<TEventHandle<TEvBlobStorage::TEvPut> *>(
-                        new IEventHandle(TActorId(),  TActorId(), vPut.release())));
+                events.emplace_back(static_cast<TEventHandleFat<TEvBlobStorage::TEvPut> *>(
+                        new IEventHandleFat(TActorId(),  TActorId(), vPut.release())));
             }
 
             TMaybe<TPutImpl> putImpl;
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp b/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp
index 397b975979a..2d36cda307b 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_sequence_ut.cpp
@@ -271,7 +271,7 @@ void SendVGetResult(ui32 vDiskIdx, NKikimrProto::EReplyStatus status, ui32 partI
     }
     result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(subgroup[vDiskIdx].MsgId);
     result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(subgroup[vDiskIdx].SequenceId);
-    runtime.Send(new IEventHandle(from->Sender, from->ActorId, result.release(), 0, from->LastCookie));
+    runtime.Send(new IEventHandleFat(from->Sender, from->ActorId, result.release(), 0, from->LastCookie));
 }
 
 void SendVGetResult(ui32 blobIdx, ui32 vDiskIdx, NKikimrProto::EReplyStatus status,
@@ -295,7 +295,7 @@ void SendVGetResult(ui32 blobIdx, ui32 vDiskIdx, NKikimrProto::EReplyStatus stat
         result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(request.MsgId);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(request.SequenceId);
         result->Record.SetCookie(request.RecordCookie);
-        runtime.Send(new IEventHandle(request.Sender, request.ActorId, result.release(), 0, request.Cookie));
+        runtime.Send(new IEventHandleFat(request.Sender, request.ActorId, result.release(), 0, request.Cookie));
         return;
     } else if (status == NKikimrProto::NODATA) {
         std::unique_ptr<TEvBlobStorage::TEvVGetResult> result(new TEvBlobStorage::TEvVGetResult(
@@ -309,7 +309,7 @@ void SendVGetResult(ui32 blobIdx, ui32 vDiskIdx, NKikimrProto::EReplyStatus stat
         result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(request.MsgId);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(request.SequenceId);
         result->Record.SetCookie(request.RecordCookie);
-        runtime.Send(new IEventHandle(request.Sender, request.ActorId, result.release(), 0, request.Cookie));
+        runtime.Send(new IEventHandleFat(request.Sender, request.ActorId, result.release(), 0, request.Cookie));
         return;
     } else if (status == NKikimrProto::OK) {
         std::unique_ptr<TEvBlobStorage::TEvVGetResult> result(new TEvBlobStorage::TEvVGetResult(
@@ -340,7 +340,7 @@ void SendVGetResult(ui32 blobIdx, ui32 vDiskIdx, NKikimrProto::EReplyStatus stat
         result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(request.MsgId);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(request.SequenceId);
         result->Record.SetCookie(request.RecordCookie);
-        runtime.Send(new IEventHandle(request.Sender, request.ActorId, result.release(), 0, request.Cookie));
+        runtime.Send(new IEventHandleFat(request.Sender, request.ActorId, result.release(), 0, request.Cookie));
         return;
     } else {
         Y_FAIL();
@@ -370,7 +370,7 @@ void SendVPutResultEvent(TTestActorRuntime &runtime, TVDiskState &vdisk, NKikimr
     vPutResult->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(vdisk.MsgId);
     vPutResult->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(vdisk.SequenceId);
     SetPredictedDelaysForAllQueues({});
-    runtime.Send(new IEventHandle(vdisk.Sender, vdisk.ActorId, vPutResult.release(), 0, vdisk.LastCookie));
+    runtime.Send(new IEventHandleFat(vdisk.Sender, vdisk.ActorId, vPutResult.release(), 0, vdisk.LastCookie));
 }
 
 void PrepareBlobSubgroup(TLogoBlobID logoblobid, TString data, TVector<TVDiskState> &subgroup,
@@ -378,7 +378,7 @@ void PrepareBlobSubgroup(TLogoBlobID logoblobid, TString data, TVector<TVDiskSta
     TActorId proxy = MakeBlobStorageProxyID(GROUP_ID);
     TActorId sender = runtime.AllocateEdgeActor(0);
 
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvPut(logoblobid, data, TInstant::Max())));
+    runtime.Send(new IEventHandleFat(proxy, sender, new TEvBlobStorage::TEvPut(logoblobid, data, TInstant::Max())));
     subgroup.resize(type.BlobSubgroupSize());
 
     ui32 partCount = type.TotalPartCount();
@@ -587,7 +587,7 @@ struct TDyingDecorator : public TTestDecorator {
     virtual ~TDyingDecorator() {
         if (NActors::TlsActivationContext) {
             std::unique_ptr<IEventBase> ev = std::make_unique<TEvRequestEnd>();
-            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(ParentId, ParentId, ev.release());
+            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandleFat>(ParentId, ParentId, ev.release());
             TActivationContext::Send(handle.release());
         }
     }
@@ -760,7 +760,7 @@ Y_UNIT_TEST(TestGivenBlock42GetThenVGetResponseParts2523Nodata4ThenGetOk) {
     TVector<TVDiskState> subgroup;
     PrepareBlobSubgroup(logoblobid, data, subgroup, runtime, type);
 
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(logoblobid, 0, 0, TInstant::Max(),
+    runtime.Send(new IEventHandleFat(proxy, sender, new TEvBlobStorage::TEvGet(logoblobid, 0, 0, TInstant::Max(),
             NKikimrBlobStorage::EGetHandleClass::FastRead)));
     for (ui32 i = 0; i < 6; ++i) {
         TAutoPtr<IEventHandle> handle;
@@ -866,7 +866,7 @@ void MakeTestProtobufSizeWithMultiGet(const TVector<TBlobPack> &packs, TVector<u
         q.Shift = 0;
         q.Size = q.Id.BlobSize();
     }
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(
+    runtime.Send(new IEventHandleFat(proxy, sender, new TEvBlobStorage::TEvGet(
         queries, blobCount, TInstant::Max(),
         NKikimrBlobStorage::EGetHandleClass::AsyncRead, false)));
 
@@ -989,7 +989,7 @@ Y_UNIT_TEST(TestGivenStripe42GetThenVGetResponsePartsNodata263451ThenGetOk) {
     TVector<TVDiskState> subgroup;
     PrepareBlobSubgroup(logoblobid, data, subgroup, runtime, type);
 
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(logoblobid, 0, 0, TInstant::Max(),
+    runtime.Send(new IEventHandleFat(proxy, sender, new TEvBlobStorage::TEvGet(logoblobid, 0, 0, TInstant::Max(),
         NKikimrBlobStorage::EGetHandleClass::FastRead)));
     for (ui32 i = 0; i < 8; ++i) {
         TAutoPtr<IEventHandle> handle;
@@ -1058,7 +1058,7 @@ Y_UNIT_TEST(TestGivenStripe42WhenGet2PartsOfBlobThenGetOk) {
         q.Shift = offsets[i];
         q.Size = sizes[i];
     }
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(
+    runtime.Send(new IEventHandleFat(proxy, sender, new TEvBlobStorage::TEvGet(
         queries, (ui32)logoblobids.size(), TInstant::Max(),
         NKikimrBlobStorage::EGetHandleClass::AsyncRead, false)));
 
@@ -1118,7 +1118,7 @@ Y_UNIT_TEST(TestGivenBlock42IntersectingPutWhenNodataOkThenOk) {
         q.Shift = offsets[i];
         q.Size = sizes[i];
     }
-    runtime.Send(new IEventHandle(proxy, sender, new TEvBlobStorage::TEvGet(
+    runtime.Send(new IEventHandleFat(proxy, sender, new TEvBlobStorage::TEvGet(
         queries, (ui32)logoblobids.size(), TInstant::Max(),
         NKikimrBlobStorage::EGetHandleClass::AsyncRead, false)));
 
@@ -1178,7 +1178,7 @@ Y_UNIT_TEST(TestGivenBlock42PutWhenPartialGetThenSingleDiskRequestOk) {
                     q.Size = size;
                 }
                 runtime.Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         proxy, sender, new TEvBlobStorage::TEvGet(
                         queries, 1, TInstant::Max(),
                         NKikimrBlobStorage::EGetHandleClass::FastRead, false)));
@@ -1220,7 +1220,7 @@ Y_UNIT_TEST(TestGivenBlock42PutWhenPartialGetThenSingleDiskRequestOk) {
                 result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(sequenceId);
                 result->Record.SetCookie(theRequest.RecordCookie);
                 runtime.Send(
-                    new IEventHandle(theRequest.Sender, theRequest.ActorId, result.release(), 0, theRequest.Cookie));
+                    new IEventHandleFat(theRequest.Sender, theRequest.ActorId, result.release(), 0, theRequest.Cookie));
 
                 // Receive GetResult
                 auto getResult = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvGetResult>(handle);
@@ -1245,7 +1245,7 @@ Y_UNIT_TEST(TestGivenBlock42PutWhenPartialGetThenSingleDiskRequestOk) {
                     result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(request.MsgId);
                     result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(request.SequenceId);
                     result->Record.SetCookie(request.RecordCookie);
-                    runtime.Send(new IEventHandle(
+                    runtime.Send(new IEventHandleFat(
                         request.Sender, request.ActorId, result.release(), 0, request.Cookie));
                 }
 
@@ -1276,7 +1276,7 @@ Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
     const ui64 tabletId = 1;
     const ui32 minGeneration = 0;
     // Send Discover
-    runtime.Send(new IEventHandle(
+    runtime.Send(new IEventHandleFat(
         proxy, sender, new TEvBlobStorage::TEvDiscover(tabletId, minGeneration, true, false, TInstant::Max(), 0, true)));
 
     // Receive VGet
@@ -1313,7 +1313,7 @@ Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
                 &ingressRaw);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(req.MsgId);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(req.SequenceId);
-        runtime.Send(new IEventHandle(req.Sender, req.ActorId, result.release(), 0, req.Cookie));
+        runtime.Send(new IEventHandleFat(req.Sender, req.ActorId, result.release(), 0, req.Cookie));
     }
 
     for (auto iter = lastRequest.begin(); iter != lastRequest.end(); ++iter) {
@@ -1329,7 +1329,7 @@ Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
         result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(req.MsgId);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(req.SequenceId);
         runtime.Send(
-            new IEventHandle(req.Sender, req.ActorId, result.release(), 0, req.Cookie));
+            new IEventHandleFat(req.Sender, req.ActorId, result.release(), 0, req.Cookie));
     }
 
     lastRequest.clear();
@@ -1360,7 +1360,7 @@ Y_UNIT_TEST(TestGivenBlock42Put6PartsOnOneVDiskWhenDiscoverThenRecoverFirst) {
         result->Record.MutableMsgQoS()->MutableMsgId()->SetMsgId(req.MsgId);
         result->Record.MutableMsgQoS()->MutableMsgId()->SetSequenceId(req.SequenceId);
         runtime.Send(
-            new IEventHandle(req.Sender, req.ActorId, result.release(), 0, req.Cookie));
+            new IEventHandleFat(req.Sender, req.ActorId, result.release(), 0, req.Cookie));
     }
     */
 
diff --git a/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h b/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h
index e6b8d2de143..4474b8b5d06 100644
--- a/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h
+++ b/ydb/core/blobstorage/dsproxy/ut/dsproxy_test_state_ut.h
@@ -95,8 +95,8 @@ struct TTestState {
     {
         std::unique_ptr<TEvBlobStorage::TEvPut> put = std::make_unique<TEvBlobStorage::TEvPut>(blob.Id, blob.Data, TInstant::Max(),
                 handleClass, tactic);
-        return static_cast<TEventHandle<TEvBlobStorage::TEvPut>*>(
-                new IEventHandle(EdgeActor, EdgeActor, put.release()));
+        return static_cast<TEventHandleFat<TEvBlobStorage::TEvPut>*>(
+                new IEventHandleFat(EdgeActor, EdgeActor, put.release()));
     }
 
     template <typename TIter, typename TPutIter>
@@ -126,8 +126,8 @@ struct TTestState {
         }
         std::unique_ptr<TEvBlobStorage::TEvGet> get = std::make_unique<TEvBlobStorage::TEvGet>(queries, blobs.size(), TInstant::Max(),
                 NKikimrBlobStorage::EGetHandleClass::FastRead, mustRestore, false);
-        return static_cast<TEventHandle<TEvBlobStorage::TEvGet>*>(
-                new IEventHandle(EdgeActor, EdgeActor, get.release()));
+        return static_cast<TEventHandleFat<TEvBlobStorage::TEvGet>*>(
+                new IEventHandleFat(EdgeActor, EdgeActor, get.release()));
     }
 
     ////////////////////////////////////////////////////////////////////////////
@@ -135,8 +135,8 @@ struct TTestState {
     ////////////////////////////////////////////////////////////////////////////
     template <typename TEvent>
     typename TEvent::TPtr CreateEventPtr(TActorId recipient, TActorId sender, TEvent *ev, ui64 cookie) {
-        TAutoPtr<IEventHandle> handle = new IEventHandle(recipient, sender, ev, 0, cookie);
-        return static_cast<TEventHandle<TEvent>*>(handle.Release());
+        TAutoPtr<IEventHandle> handle = new IEventHandleFat(recipient, sender, ev, 0, cookie);
+        return static_cast<TEventHandleFat<TEvent>*>(handle.Release());
     }
 
     template <typename TEvent>
@@ -149,7 +149,7 @@ struct TTestState {
         TAutoPtr<IEventHandle> handle;
         auto ev = Runtime.GrabEdgeEventRethrow<TEvent>(handle);
         UNIT_ASSERT(ev);
-        return static_cast<TEventHandle<TEvent>*>(handle.Release());
+        return static_cast<TEventHandleFat<TEvent>*>(handle.Release());
     }
 
     template <typename TEventPtr, typename ...TArgs>
diff --git a/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp b/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
index 6560fa4ec8a..70b1733d139 100644
--- a/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
+++ b/ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
@@ -3428,7 +3428,7 @@ class TTestBlobStorageProxyBatchedPutRequestDoesNotContainAHugeBlob : public TTe
     TEvBlobStorage::TEvPut::TPtr GetPut(TLogoBlobID id, const TString &data) {
         std::unique_ptr<TEvBlobStorage::TEvPut> put = std::make_unique<TEvBlobStorage::TEvPut>(id, data,
                 TInstant::Max(), HandleClass, Tactic);
-        return static_cast<TEventHandle<TEvBlobStorage::TEvPut>*>(new IEventHandle(SelfId(), SelfId(), put.release()));
+        return static_cast<TEventHandleFat<TEvBlobStorage::TEvPut>*>(new IEventHandleFat(SelfId(), SelfId(), put.release()));
     }
 
     TEvBlobStorage::TEvPut::ETactic Tactic = TEvBlobStorage::TEvPut::TacticDefault;
diff --git a/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_read_log.cpp b/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_read_log.cpp
index e0dd683010e..88b8ea0d2ec 100644
--- a/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_read_log.cpp
+++ b/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_read_log.cpp
@@ -32,7 +32,7 @@ namespace NKikimr {
 
         private:
             TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override {
-                return new IEventHandle(self, parentId, new TEvents::TEvBootstrap);
+                return new IEventHandleFat(self, parentId, new TEvents::TEvBootstrap);
             }
 
             void Handle(TEvents::TEvBootstrap::TPtr& ev, const TActorContext& ctx) {
diff --git a/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_scan.cpp b/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_scan.cpp
index eb60105861b..e725336faf7 100644
--- a/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_scan.cpp
+++ b/ydb/core/blobstorage/incrhuge/incrhuge_keeper_recovery_scan.cpp
@@ -29,7 +29,7 @@ namespace NKikimr {
 
         private:
             TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override {
-                return new IEventHandle(self, parentId, new TEvents::TEvBootstrap);
+                return new IEventHandleFat(self, parentId, new TEvents::TEvBootstrap);
             }
 
             void Handle(TEvents::TEvBootstrap::TPtr& ev, const TActorContext& ctx) {
diff --git a/ydb/core/blobstorage/incrhuge/ut/faulty_pdisk.h b/ydb/core/blobstorage/incrhuge/ut/faulty_pdisk.h
index 73735697022..d2a1a89f6c4 100644
--- a/ydb/core/blobstorage/incrhuge/ut/faulty_pdisk.h
+++ b/ydb/core/blobstorage/incrhuge/ut/faulty_pdisk.h
@@ -18,7 +18,7 @@ public:
             Event->Signal();
             Die(ctx);
         } else {
-            ctx.ExecutorThread.Send(ev->Forward(PDiskId));
+            Forward(ev, PDiskId);
         }
     }
 };
diff --git a/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp b/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp
index b5896de7ee1..8bf474f19d5 100644
--- a/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp
+++ b/ydb/core/blobstorage/incrhuge/ut/incrhuge_basic_ut.cpp
@@ -59,7 +59,7 @@ public:
             PDiskGuid = Now().GetValue();
             PDiskKey = 1;
             MainKey = {1};
-            FormatPDisk(Path, DiskSize, 4096, ChunkSize, PDiskGuid, PDiskKey, PDiskKey, PDiskKey, MainKey.back(), "incrhuge", 
+            FormatPDisk(Path, DiskSize, 4096, ChunkSize, PDiskGuid, PDiskKey, PDiskKey, PDiskKey, MainKey.back(), "incrhuge",
                 false, false, nullptr, false);
         }
 
@@ -193,7 +193,7 @@ Y_UNIT_TEST_SUITE(TIncrHugeBasicTest) {
             100000 /* writeScore */, 80000 /* deleteScore */, 0 /* readScore */);
         env.ActorSystem->Register(actor);
 //        usleep(1 * 1000 * 1000);
-//        env.ActorSystem->Send(new IEventHandle(env.KeeperId, id, new TEvIncrHugeControlDefrag(0.8)));
+//        env.ActorSystem->Send(new IEventHandleFat(env.KeeperId, id, new TEvIncrHugeControlDefrag(0.8)));
         event.WaitI();
         usleep(50 * 1000 * 1000); // wait for defragment
         env.Stop();
diff --git a/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp b/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp
index c80b263c77e..6b7a7ea91ca 100644
--- a/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp
+++ b/ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp
@@ -295,7 +295,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         pdisk->SetPDiskGuid(guid);
         pdisk->SetPDiskCategory(pDiskCategory);
         pdisk->SetEntityStatus(NKikimrBlobStorage::CREATE);
-        runtime.Send(new IEventHandle(MakeBlobStorageNodeWardenID(nodeId), TActorId(), ev.release()));
+        runtime.Send(new IEventHandleFat(MakeBlobStorageNodeWardenID(nodeId), TActorId(), ev.release()));
 
         return pdiskId;
     }
@@ -306,7 +306,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         ui32 nodeId = sender.NodeId();
         TActorId nodeWarden = MakeBlobStorageNodeWardenID(nodeId);
         ui64 cookie = 6543210;
-        runtime.Send(new IEventHandle(proxy, sender,
+        runtime.Send(new IEventHandleFat(proxy, sender,
             new TEvBlobStorage::TEvPut(logoBlobId, data, TInstant::Max()),
             IEventHandle::FlagForwardOnNondelivery, cookie, &nodeWarden), sender.NodeId() - runtime.GetNodeId(0));
 
@@ -364,7 +364,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
 
         TActorId recipient = MakeBlobStorageProxyID(groupId);
         TActorId nodeWarden = MakeBlobStorageNodeWardenID(sender.NodeId());
-        return runtime.Send(new IEventHandle(recipient, sender, ev,
+        return runtime.Send(new IEventHandleFat(recipient, sender, ev,
             flags, cookie, &nodeWarden, {}), sender.NodeId() - runtime.GetNodeId(0));
     }
 
@@ -669,7 +669,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         ui32 nodeId = runtime.GetNodeId(0);
         TActorId pDiskActorId = MakeBlobStoragePDiskID(nodeId, pDiskId);
         for (;;) {
-            runtime.Send(new IEventHandle(pDiskActorId, sender0, new NPDisk::TEvYardInit(1, vDiskId, guid)), 0);
+            runtime.Send(new IEventHandleFat(pDiskActorId, sender0, new NPDisk::TEvYardInit(1, vDiskId, guid)), 0);
             TAutoPtr<IEventHandle> handle;
             if (auto initResult = runtime.GrabEdgeEventRethrow<NPDisk::TEvYardInitResult>(handle, TDuration::Seconds(1))) {
                 UNIT_ASSERT(initResult);
@@ -687,7 +687,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         THttpRequest HttpRequest;
         NMonitoring::TMonService2HttpRequest monService2HttpRequest(nullptr, &HttpRequest, nullptr, nullptr, path,
                 nullptr);
-        runtime.Send(new IEventHandle(nodeWarden, edge, new NMon::TEvHttpInfo(monService2HttpRequest)), 0);
+        runtime.Send(new IEventHandleFat(nodeWarden, edge, new NMon::TEvHttpInfo(monService2HttpRequest)), 0);
         auto httpInfoRes = runtime.GrabEdgeEventRethrow<NMon::TEvHttpInfoRes>(edge, TDuration::Seconds(1));
         UNIT_ASSERT(httpInfoRes && httpInfoRes->Get());
         TStringStream out;
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_group.cpp b/ydb/core/blobstorage/nodewarden/node_warden_group.cpp
index 5add33077dc..a92d2ee795f 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_group.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_group.cpp
@@ -116,7 +116,7 @@ namespace NKikimr::NStorage {
         }
 
         if (group.GroupResolver && !group.GetGroupRequestPending) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, group.GroupResolver, {}, nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, group.GroupResolver, {}, nullptr, 0));
             group.GroupResolver = {};
         }
 
@@ -155,7 +155,7 @@ namespace NKikimr::NStorage {
 
                     if (ep.GetLifeCyclePhase() == TBlobStorageGroupInfo::ELCP_IN_TRANSITION) {
                         // re-request group configuration for this group after some timeout
-                        TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(TEvPrivate::EvGetGroup, 0,
+                        TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(TEvPrivate::EvGetGroup, 0,
                             SelfId(), {}, nullptr, groupId));
                     }
                 }
@@ -251,10 +251,10 @@ namespace NKikimr::NStorage {
                     TGroupRecord& group = Groups[groupId];
                     STLOG(PRI_DEBUG, BS_NODE, NW99, "destroying group", (GroupId, groupId), (ProxyId, group.ProxyId));
                     if (group.ProxyId) {
-                        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, group.ProxyId, {}, nullptr, 0));
+                        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, group.ProxyId, {}, nullptr, 0));
                     }
                     if (group.GroupResolver) {
-                        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, group.GroupResolver, {}, nullptr, 0));
+                        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, group.GroupResolver, {}, nullptr, 0));
                     }
                     Groups.erase(groupId);
 
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_group_resolver.cpp b/ydb/core/blobstorage/nodewarden/node_warden_group_resolver.cpp
index c86b742e247..635c846a0f5 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_group_resolver.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_group_resolver.cpp
@@ -98,7 +98,7 @@ namespace NKikimr::NStorage {
                 }
             }
             for (TActorId actorId : std::exchange(Ctx.NodeIdsWaitQueue, {})) { // notify waiting actors
-                TActivationContext::Send(new IEventHandle(TEvPrivate::EvNodeIdsObtained, 0, actorId, {}, {}, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvPrivate::EvNodeIdsObtained, 0, actorId, {}, {}, 0));
             }
             HandleNodeIdsObtained();
         }
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp b/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
index 7e66d81f4c0..9a9c5fa8119 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
@@ -42,14 +42,14 @@ void TNodeWarden::StartInvalidGroupProxy() {
 void TNodeWarden::StopInvalidGroupProxy() {
     ui32 groupId = Max<ui32>();
     STLOG(PRI_DEBUG, BS_NODE, NW15, "StopInvalidGroupProxy", (GroupId, groupId));
-    TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, MakeBlobStorageProxyID(groupId), {}, nullptr, 0));
+    TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, MakeBlobStorageProxyID(groupId), {}, nullptr, 0));
 }
 
 void TNodeWarden::PassAway() {
     STLOG(PRI_DEBUG, BS_NODE, NW25, "PassAway");
     NTabletPipe::CloseClient(SelfId(), PipeClientId);
     StopInvalidGroupProxy();
-    TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, DsProxyNodeMonActor, {}, nullptr, 0));
+    TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, DsProxyNodeMonActor, {}, nullptr, 0));
     return TActorBootstrapped::PassAway();
 }
 
@@ -120,7 +120,7 @@ void TNodeWarden::Bootstrap() {
     Send(GetNameserviceActorId(), new TEvInterconnect::TEvGetNode(LocalNodeId));
 
     if (Cfg->IsCacheEnabled()) {
-        TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandle(TEvPrivate::EvReadCache, 0, SelfId(), {}, nullptr, 0));
+        TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandleFat(TEvPrivate::EvReadCache, 0, SelfId(), {}, nullptr, 0));
     }
 
     StartInvalidGroupProxy();
@@ -185,7 +185,7 @@ void TNodeWarden::Handle(NPDisk::TEvSlayResult::TPtr ev) {
     STLOG(PRI_INFO, BS_NODE, NW28, "Handle(NPDisk::TEvSlayResult)", (Msg, msg.ToString()));
     switch (msg.Status) {
         case NKikimrProto::NOTREADY:
-            TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandle(MakeBlobStoragePDiskID(LocalNodeId,
+            TActivationContext::Schedule(TDuration::Seconds(1), new IEventHandleFat(MakeBlobStoragePDiskID(LocalNodeId,
                 msg.PDiskId), SelfId(), new NPDisk::TEvSlay(msg.VDiskId, msg.SlayOwnerRound, msg.PDiskId, msg.VSlotId)));
             break;
 
@@ -524,7 +524,7 @@ bool NKikimr::ObtainPDiskKey(TVector<TEncryptionKey> *keys, const NKikimrProto::
             if (!ObtainKey(&(*keys)[i], record)) {
                 return false;
             }
-        } 
+        }
     }
 
     std::sort(keys->begin(), keys->end(), [&](const TEncryptionKey& l, const TEncryptionKey& r) {
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp b/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp
index bdd741f6d4e..c37c86421ad 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp
@@ -180,7 +180,7 @@ namespace NKikimr::NStorage {
         STLOG(PRI_INFO, BS_NODE, NW36, "DestroyLocalPDisk", (PDiskId, pdiskId));
         if (auto it = LocalPDisks.find({LocalNodeId, pdiskId}); it != LocalPDisks.end()) {
             const TActorId actorId = MakeBlobStoragePDiskID(LocalNodeId, pdiskId);
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
             Send(WhiteboardId, new NNodeWhiteboard::TEvWhiteboard::TEvPDiskStateDelete(pdiskId));
             LocalPDisks.erase(it);
 
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_proxy.cpp b/ydb/core/blobstorage/nodewarden/node_warden_proxy.cpp
index 3fc7d9287b5..230685a1617 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_proxy.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_proxy.cpp
@@ -87,8 +87,8 @@ void TNodeWarden::HandleForwarded(TAutoPtr<::NActors::IEventHandle> &ev) {
         // invalid group; proxy for this group is created at start
     } else if (noGroup) {
         const TActorId errorProxy = StartEjectedProxy(id);
-        TActivationContext::Send(ev->Forward(errorProxy));
-        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, errorProxy, {}, nullptr, 0));
+        TActivationContext::Forward(ev, errorProxy);
+        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, errorProxy, {}, nullptr, 0));
         return;
     } else if (TGroupRecord& group = Groups[id]; !group.ProxyId) {
         if (TGroupID(id).ConfigurationType() == EGroupConfigurationType::Virtual) {
@@ -97,8 +97,7 @@ void TNodeWarden::HandleForwarded(TAutoPtr<::NActors::IEventHandle> &ev) {
             StartLocalProxy(id);
         }
     }
-
-    TActivationContext::Send(ev->Forward(ev->GetForwardOnNondeliveryRecipient()));
+    TActivationContext::Forward(ev, ev->GetForwardOnNondeliveryRecipient());
 }
 
 void TNodeWarden::Handle(NNodeWhiteboard::TEvWhiteboard::TEvBSGroupStateUpdate::TPtr ev) {
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_resource.cpp b/ydb/core/blobstorage/nodewarden/node_warden_resource.cpp
index 3498e2174c4..6e06265cc87 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_resource.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_resource.cpp
@@ -16,7 +16,7 @@ void TNodeWarden::RegisterPendingActor(const TActorId& actorId) {
 }
 
 void TNodeWarden::EnqueuePendingMessage(TAutoPtr<IEventHandle> ev) {
-    ev = ev->Forward(ev->GetForwardOnNondeliveryRecipient());
+    IEventHandle::Forward(ev, ev->GetForwardOnNondeliveryRecipient());
     const auto it = PendingMessageQ.find(ev->Recipient);
     if (it != PendingMessageQ.end()) {
         it->second.emplace_back(ev.Release());
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_stat_aggr.cpp b/ydb/core/blobstorage/nodewarden/node_warden_stat_aggr.cpp
index 6a357489fc5..00ddbec03e8 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_stat_aggr.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_stat_aggr.cpp
@@ -49,7 +49,7 @@ void TNodeWarden::StartAggregator(const TActorId& vdiskServiceId, ui32 groupId)
 void TNodeWarden::StopAggregator(const TActorId& vdiskServiceId) {
     if (RunningVDiskServiceIds.erase(vdiskServiceId)) {
         const TActorId groupStatAggregatorId = MakeGroupStatAggregatorId(vdiskServiceId);
-        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, groupStatAggregatorId, {}, nullptr, 0));
+        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, groupStatAggregatorId, {}, nullptr, 0));
         PerAggregatorInfo.erase(groupStatAggregatorId);
     }
 }
diff --git a/ydb/core/blobstorage/nodewarden/node_warden_vdisk.cpp b/ydb/core/blobstorage/nodewarden/node_warden_vdisk.cpp
index 3a659bfce60..c76597d6bec 100644
--- a/ydb/core/blobstorage/nodewarden/node_warden_vdisk.cpp
+++ b/ydb/core/blobstorage/nodewarden/node_warden_vdisk.cpp
@@ -25,7 +25,7 @@ namespace NKikimr::NStorage {
 
         if (vdisk.RuntimeData) {
             vdisk.TIntrusiveListItem<TVDiskRecord, TGroupRelationTag>::Unlink();
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, vdisk.GetVDiskServiceId(), {}, nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, vdisk.GetVDiskServiceId(), {}, nullptr, 0));
             vdisk.RuntimeData.reset();
         }
 
diff --git a/ydb/core/blobstorage/nodewarden/ut_sequence/dsproxy_config_retrieval.cpp b/ydb/core/blobstorage/nodewarden/ut_sequence/dsproxy_config_retrieval.cpp
index 16648d78cb8..55fa33d3e20 100644
--- a/ydb/core/blobstorage/nodewarden/ut_sequence/dsproxy_config_retrieval.cpp
+++ b/ydb/core/blobstorage/nodewarden/ut_sequence/dsproxy_config_retrieval.cpp
@@ -85,7 +85,7 @@ void SetupServices(TTestBasicRuntime& runtime) {
     {
         TActorId edge = runtime.AllocateEdgeActor();
 
-        runtime.Send(new IEventHandle(GetNameserviceActorId(), edge, new TEvInterconnect::TEvListNodes));
+        runtime.Send(new IEventHandleFat(GetNameserviceActorId(), edge, new TEvInterconnect::TEvListNodes));
         TAutoPtr<IEventHandle> handleNodesInfo;
         auto nodesInfo = runtime.GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(handleNodesInfo);
 
@@ -187,9 +187,9 @@ Y_UNIT_TEST_SUITE(NodeWardenDsProxyConfigRetrieval) {
         const TActorId sender = runtime.AllocateEdgeActor(0);
         const TActorId warden = MakeBlobStorageNodeWardenID(runtime.GetNodeId(0));
         Cerr << "=== Breaking pipe ===" << Endl;
-        runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, clientId, TActorId(), {}, 0));
+        runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, clientId, TActorId(), {}, 0));
         Cerr << "=== Sending put ===" << Endl;
-        runtime.Send(new IEventHandle(recip, sender, new TEvBlobStorage::TEvPut(TLogoBlobID(1, 1, 1, 1, 1, 1), "1", TInstant::Max()),
+        runtime.Send(new IEventHandleFat(recip, sender, new TEvBlobStorage::TEvPut(TLogoBlobID(1, 1, 1, 1, 1, 1), "1", TInstant::Max()),
             IEventHandle::FlagForwardOnNondelivery, 0, &warden), 0, true);
         allowConfiguring = true;
         auto res = runtime.GrabEdgeEvent<TEvBlobStorage::TEvPutResult>(sender);
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
index f46c1f368c6..499ff1187db 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp
@@ -365,7 +365,7 @@ public:
                             try {
                                 FormatPDisk(cfg->GetDevicePath(), 0, cfg->SectorSize, cfg->ChunkSize,
                                     cfg->PDiskGuid, chunkKey, logKey, sysLogKey, actor->MainKey.back(), TString(), false,
-                                    cfg->FeatureFlags.GetTrimEntireDeviceOnStartup(), cfg->SectorMap, 
+                                    cfg->FeatureFlags.GetTrimEntireDeviceOnStartup(), cfg->SectorMap,
                                     cfg->FeatureFlags.GetEnableSmallDiskOptimization());
                             } catch (NPDisk::TPDiskFormatBigChunkException) {
                                 FormatPDisk(cfg->GetDevicePath(), 0, cfg->SectorSize, NPDisk::SmallDiskMaximumChunkSize,
@@ -570,7 +570,7 @@ public:
         const NPDisk::TEvYardControl &evControl = *ev->Get();
         switch (evControl.Action) {
         case TEvYardControl::PDiskStart:
-            ControledStartResult = MakeHolder<IEventHandle>(ev->Sender, SelfId(),
+            ControledStartResult = MakeHolder<IEventHandleFat>(ev->Sender, SelfId(),
                     new TEvYardControlResult(NKikimrProto::OK, evControl.Cookie, {}));
         break;
         default:
@@ -729,7 +729,7 @@ public:
             Y_VERIFY(mainKey);
             MainKey = *mainKey;
             StartPDiskThread();
-            ControledStartResult = MakeHolder<IEventHandle>(ev->Sender, SelfId(),
+            ControledStartResult = MakeHolder<IEventHandleFat>(ev->Sender, SelfId(),
                     new TEvYardControlResult(NKikimrProto::OK, evControl.Cookie, {}));
             break;
         }
@@ -1055,7 +1055,7 @@ public:
                         NPDisk::TEvChunkUnlock(lockFrom), ev->Sender);
                     PDisk->InputRequest(request);
                 }
-            } 
+            }
         }
         if (cgi.Has("restartPDisk")) {
             if (Cfg->SectorMap || CurrentStateFunc() == &TPDiskActor::StateError) {
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
index 3403c678f99..085880d0ac6 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
@@ -734,7 +734,7 @@ void TPDisk::AskVDisksToCutLogs(TOwner ownerFilter, bool doForce) {
                                 << " Send CutLog to# " << OwnerData[chunkOwner].CutLogId.ToString().data()
                                 << " ownerId#" << ui32(chunkOwner)
                                 << " cutLog# " << cutLog->ToString());
-                        ActorSystem->Send(new IEventHandle(OwnerData[chunkOwner].CutLogId, PDiskActor, cutLog.Release(),
+                        ActorSystem->Send(new IEventHandleFat(OwnerData[chunkOwner].CutLogId, PDiskActor, cutLog.Release(),
                                     IEventHandle::FlagTrackDelivery, 0));
                         OwnerData[chunkOwner].AskedToCutLogAt = now;
                     } else {
@@ -777,7 +777,7 @@ void TPDisk::AskVDisksToCutLogs(TOwner ownerFilter, bool doForce) {
                                 << " cutLog# " << cutLog->ToString()
                                 << " LogChunks# " << str.Str());
                     }
-                    ActorSystem->Send(new IEventHandle(OwnerData[ownerFilter].CutLogId, PDiskActor, cutLog.Release(),
+                    ActorSystem->Send(new IEventHandleFat(OwnerData[ownerFilter].CutLogId, PDiskActor, cutLog.Release(),
                                 IEventHandle::FlagTrackDelivery, 0));
                     OwnerData[ownerFilter].AskedToCutLogAt = now;
                 } else {
@@ -1092,7 +1092,7 @@ std::unique_ptr<TEvChunkLockResult> TPDisk::ChunkLockFromQuota(TOwner owner, NKi
     ui32 number = Keeper.ColorFlagLimit(owner, color);
     ui32 used = Keeper.GetOwnerUsed(owner);
     if (number <= used) {
-        LOG_ERROR_S(*ActorSystem, NKikimrServices::BS_PDISK, 
+        LOG_ERROR_S(*ActorSystem, NKikimrServices::BS_PDISK,
             "Can't lock chunks by color# " << TPDiskSpaceColor_Name(color) <<
             ", this space color flag is already raised. Marker# BPD33");
         return std::unique_ptr<TEvChunkLockResult>(new NPDisk::TEvChunkLockResult(NKikimrProto::ERROR,
@@ -1165,7 +1165,7 @@ void TPDisk::ChunkLock(TChunkLock &evChunkLock) {
     } else {
         result.reset(ChunkLockFromQuota(owner, evChunkLock.Color).release());
     }
-    
+
     LOG_INFO(*ActorSystem, NKikimrServices::BS_PDISK, "PDiskId# %" PRIu32 " Locked %" PRIu32 \
         " chunks from owner# " PRIu32, (ui32)PDiskId, (ui32)result->LockedChunks.size(), (ui32)owner);
 
@@ -3530,7 +3530,7 @@ void TPDisk::Update() {
             } else {
                 diskModeParams->LastSectorRate.store(SectorMapLastSectorRate);
             }
-            
+
             diskModeParams->SeekSleepMicroSeconds.store(SectorMapSeekSleepMicroSeconds);
         }
     }
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_req_creator.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_req_creator.h
index 88adf2d6e1a..c74e3973360 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_req_creator.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_req_creator.h
@@ -166,7 +166,7 @@ private:
     }
 
     template<typename TEv>
-    static TString ToString(const TAutoPtr<NActors::TEventHandle<TEv>> &ev) {
+    static TString ToString(const TAutoPtr<NActors::TEventHandleFat<TEv>> &ev) {
         Y_VERIFY(ev && ev->Get());
         return ev->Get()->ToString();
     }
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
index ca994043849..5c095b249ea 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
@@ -433,8 +433,8 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                 new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
-        TEvents::TEvUndelivered::TPtr ev = reinterpret_cast<TEventHandle<TEvents::TEvUndelivered>*>(
-            new IEventHandle(
+        TEvents::TEvUndelivered::TPtr ev = reinterpret_cast<TEventHandleFat<TEvents::TEvUndelivered>*>(
+            new IEventHandleFat(
                 testCtx.Sender, testCtx.Sender,
                 new TEvents::TEvUndelivered(0, 0)
             )
@@ -689,7 +689,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         const TString data = PrepareData(4096);
 
         TActorTestContext testCtx({ false });
-        
+
         TVDiskMock mock(&testCtx);
         mock.InitFull();
 
@@ -701,12 +701,12 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                     new NPDisk::TEvChunkRead(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
                             chunk, 0, data.size(), 0, nullptr),
                     NKikimrProto::OK);
-            UNIT_ASSERT_VALUES_EQUAL(evReadRes->Data.ToString(), data); 
+            UNIT_ASSERT_VALUES_EQUAL(evReadRes->Data.ToString(), data);
         };
 
         TString dataCopy = data;
         testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
-            chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0), 
+            chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0),
             NKikimrProto::OK);
         mock.CommitReservedChunks();
 
@@ -743,7 +743,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         const TString data = PrepareData(4096);
 
         TActorTestContext testCtx({ false });
-        
+
         TVDiskMock mock(&testCtx);
         mock.InitFull();
 
@@ -752,7 +752,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
 
         TString dataCopy = data;
         testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
-            chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0), 
+            chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0),
             NKikimrProto::OK);
         mock.CommitReservedChunks();
         testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
@@ -767,7 +767,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                 NKikimrProto::OK);
-            
+
         testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStart, (void*)(&testCtx.MainKey)),
                 NKikimrProto::CORRUPTED);
@@ -776,7 +776,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     Y_UNIT_TEST(SmallDisk) {
         for (ui64 diskSizeGb : {40, 20, 10}) {
             ui64 diskSize = diskSizeGb << 30;
-            TActorTestContext testCtx({ 
+            TActorTestContext testCtx({
                 .IsBad = false,
                 .DiskSize = diskSize,
                 .SmallDisk = true,
@@ -799,7 +799,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                             TString data(NPDisk::SmallDiskMaximumChunkSize, '0');
                             testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(
                                 evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound,
-                                chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(data), nullptr, false, 0), 
+                                chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(data), nullptr, false, 0),
                                 NKikimrProto::OK);
                             dataMb += NPDisk::SmallDiskMaximumChunkSize >> 20;
                         } else {
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
index 8211700e834..fda4c826dd7 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
@@ -1,4 +1,4 @@
-#pragma once 
+#pragma once
 
 #include <ydb/core/blobstorage/pdisk/mock/pdisk_mock.h>
 #include "blobstorage_pdisk_ut.h"
@@ -93,7 +93,7 @@ public:
                     new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                     NKikimrProto::OK);
             PDisk = nullptr;
-            Runtime->Send(new IEventHandle(*PDiskActor, Sender, new TKikimrEvents::TEvPoisonPill));
+            Runtime->Send(new IEventHandleFat(*PDiskActor, Sender, new TKikimrEvents::TEvPoisonPill));
         }
 
         if (Settings.UsePDiskMock) {
@@ -109,7 +109,7 @@ public:
     }
 
     void Send(IEventBase* ev) {
-        Runtime->Send(new IEventHandle(*PDiskActor, Sender, ev));
+        Runtime->Send(new IEventHandleFat(*PDiskActor, Sender, ev));
     }
 
     NPDisk::TPDisk *GetPDisk() {
diff --git a/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp b/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
index 173d3ff047e..7ea7bd0a823 100644
--- a/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
+++ b/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
@@ -218,7 +218,7 @@ struct TPDiskMockState::TImpl {
     void TrimQuery() {
         for (auto& [ownerId, owner] : Owners) {
             if (!owner.Log.empty()) {
-                TActivationContext::Send(new IEventHandle(owner.CutLogId, {}, new NPDisk::TEvCutLog(ownerId,
+                TActivationContext::Send(new IEventHandleFat(owner.CutLogId, {}, new NPDisk::TEvCutLog(ownerId,
                     owner.OwnerRound, owner.Log.back().Lsn + 1, 0, 0, 0, 0)));
             }
         }
@@ -415,14 +415,14 @@ public:
 
     void Handle(NPDisk::TEvLog::TPtr ev) {
         if (LogQ.empty()) {
-            TActivationContext::Send(new IEventHandle(EvResume, 0, SelfId(), TActorId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(EvResume, 0, SelfId(), TActorId(), nullptr, 0));
         }
         LogQ.emplace_back(ev->Sender, ev->Release());
     }
 
     void Handle(NPDisk::TEvMultiLog::TPtr ev) {
         if (LogQ.empty()) {
-            TActivationContext::Send(new IEventHandle(EvResume, 0, SelfId(), TActorId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(EvResume, 0, SelfId(), TActorId(), nullptr, 0));
         }
         for (auto& msg : ev->Get()->Logs) {
             LogQ.emplace_back(ev->Sender, std::move(msg));
@@ -439,7 +439,7 @@ public:
             auto addRes = [&](NKikimrProto::EReplyStatus status, const TString& errorReason = TString()) {
                 auto p = std::make_unique<NPDisk::TEvLogResult>(status, GetStatusFlags(), errorReason);
                 res = p.get();
-                results.emplace_back(new IEventHandle(recipient, SelfId(), p.release()));
+                results.emplace_back(new IEventHandleFat(recipient, SelfId(), p.release()));
             };
             if (const auto it = Impl.Owners.find(msg->Owner); it == Impl.Owners.end()) {
                 Y_FAIL("invalid Owner");
diff --git a/ydb/core/blobstorage/ut_blobstorage/assimilation.cpp b/ydb/core/blobstorage/ut_blobstorage/assimilation.cpp
index 2c4ef621a9e..c5d40db754d 100644
--- a/ydb/core/blobstorage/ut_blobstorage/assimilation.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/assimilation.cpp
@@ -95,7 +95,7 @@ Y_UNIT_TEST_SUITE(VDiskAssimilation) {
                 auto ev = std::make_unique<TEvBlobStorage::TEvVAssimilate>(info->GetVDiskId(i), lastBlock, lastBarrier,
                     lastBlob);
                 ev->Record.SetIgnoreDecommitState(true);
-                runtime->Send(new IEventHandle(vdiskId, client, ev.release()), vdiskId.NodeId());
+                runtime->Send(new IEventHandleFat(vdiskId, client, ev.release()), vdiskId.NodeId());
                 auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVAssimilateResult>(client);
                 const auto& record = res->Get()->Record;
                 UNIT_ASSERT_VALUES_EQUAL(record.GetStatus(), NKikimrProto::OK);
@@ -145,7 +145,7 @@ Y_UNIT_TEST_SUITE(VDiskAssimilation) {
 
                     UNIT_ASSERT(!lastBlob || *lastBlob < TLogoBlobID(raw));
                     lastBlob.emplace(raw);
-                    
+
                     TIngress ingress(item.GetIngress());
                     if (const auto& p = ingress.LocalParts(info->Type); !p.Empty()) {
                         aBlobs.emplace(*lastBlob);
diff --git a/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.cpp b/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.cpp
index 842a9f142be..603d904b7b6 100644
--- a/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.cpp
@@ -36,7 +36,7 @@ std::unique_ptr<IEventHandle> CaptureAnyResult(TEnvironmentSetup& env, TActorId
     });
 
     wakeup = env.Runtime->AllocateEdgeActor(sender.NodeId(), __FILE__, __LINE__);
-    env.Runtime->Schedule(deadline, new IEventHandle(TEvents::TSystem::Wakeup, 0, wakeup, {}, nullptr, 0), nullptr,
+    env.Runtime->Schedule(deadline, new IEventHandleFat(TEvents::TSystem::Wakeup, 0, wakeup, {}, nullptr, 0), nullptr,
         wakeup.NodeId());
     ids.insert(wakeup);
 
@@ -57,7 +57,7 @@ std::unique_ptr<IEventHandle> CaptureAnyResult(TEnvironmentSetup& env, TActorId
 void SendTEvPut(TEnvironmentSetup& env, TActorId sender, ui32 groupId, TLogoBlobID id, TString data, ui64 cookie) {
     auto ev = new TEvBlobStorage::TEvPut(id, data, TInstant::Max());
 
-#ifdef LOG_PUT        
+#ifdef LOG_PUT
     Cerr << "Request# " << ev->Print(false) << Endl;
 #endif
 
@@ -66,7 +66,7 @@ void SendTEvPut(TEnvironmentSetup& env, TActorId sender, ui32 groupId, TLogoBlob
     });
 }
 
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvPutResult>> CaptureTEvPutResult(TEnvironmentSetup& env, 
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvPutResult>> CaptureTEvPutResult(TEnvironmentSetup& env,
         TActorId sender, bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvPutResult>(sender, termOnCapture, deadline);
@@ -79,7 +79,7 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvPutResult>> CaptureTEvPutResult(TEnviro
     return res.Release();
 }
 
-void VerifyTEvPutResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvPutResult>> res, TBlobInfo& blob, TBSState& state) {
+void VerifyTEvPutResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvPutResult>> res, TBlobInfo& blob, TBSState& state) {
     ui32 blockedGen = state[blob.Id.TabletID()].BlockedGen;
     ui32 softCollectGen = state[blob.Id.TabletID()].Channels[blob.Id.Channel()].SoftCollectGen;
     ui32 softCollectStep = state[blob.Id.TabletID()].Channels[blob.Id.Channel()].SoftCollectStep;
@@ -94,9 +94,9 @@ void VerifyTEvPutResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvPutResult>> res
         blob.Status = TBlobInfo::EStatus::UNKNOWN;
         return;
     }
-    
+
     if (blob.Id.Generation() <= blockedGen) {
-        UNIT_ASSERT_VALUES_EQUAL_C(status, NKikimrProto::BLOCKED, TStringBuilder() << 
+        UNIT_ASSERT_VALUES_EQUAL_C(status, NKikimrProto::BLOCKED, TStringBuilder() <<
             "Unblocked put over the barrier, blob id# " << blob.Id.ToString() << ", blocked generation# " << blockedGen);
     } else if (IsCollected(blob, softCollectGen, softCollectStep, hardCollectGen, hardCollectStep) ) {
         if (status == NKikimrProto::OK) {
@@ -130,12 +130,12 @@ void SendTEvGet(TEnvironmentSetup& env, TActorId sender, ui32 groupId, TLogoBlob
     });
 }
 
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> CaptureTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> CaptureTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvGetResult>(sender, termOnCapture, deadline);
     UNIT_ASSERT(res);
 
-#ifdef LOG_GET        
+#ifdef LOG_GET
     Cerr << "Response# " << res->Get()->ToString() << Endl;
 #endif
 
@@ -143,9 +143,9 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> CaptureTEvGetResult(TEnviro
 }
 
 
-void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res,
+void VerifyTEvGetResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> res,
         TBlobInfo& blob, bool mustRestoreFirst, bool isIndexOnly, std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData,
-        TBSState& state) 
+        TBSState& state)
 {
     Y_UNUSED(forceBlockTabletData);
 
@@ -160,8 +160,8 @@ void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res
     if (status == NKikimrProto::OK) {
         UNIT_ASSERT_VALUES_EQUAL(res->Get()->ResponseSz, 1);
         if ((blob.Status == TBlobInfo::EStatus::COLLECTED) || IsCollected(blob, softCollectGen, softCollectStep, hardCollectGen, hardCollectStep)) {
-            if (responses[0].Status == NKikimrProto::OK) { 
-                Cerr << "Read over the barrier, blob id# " << responses[0].Id.ToString() << Endl; 
+            if (responses[0].Status == NKikimrProto::OK) {
+                Cerr << "Read over the barrier, blob id# " << responses[0].Id.ToString() << Endl;
             }
             blob.Status = TBlobInfo::EStatus::COLLECTED;
         } else if (blob.Status == TBlobInfo::EStatus::WRITTEN) {
@@ -176,8 +176,8 @@ void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res
                 blob.Status = TBlobInfo::EStatus::WRITTEN;
             }
         } else {
-            if (responses[0].Status != NKikimrProto::NODATA) { 
-                Cerr << "Read non-put blob id# " << responses[0].Id.ToString() << Endl; 
+            if (responses[0].Status != NKikimrProto::NODATA) {
+                Cerr << "Read non-put blob id# " << responses[0].Id.ToString() << Endl;
             }
         }
     }
@@ -185,7 +185,7 @@ void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res
 
 void VerifiedGet(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId,
         TBlobInfo& blob, bool mustRestoreFirst, bool isIndexOnly, std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData,
-        TBSState& state, bool withDeadline) 
+        TBSState& state, bool withDeadline)
 {
     auto sender = env.Runtime->AllocateEdgeActor(nodeId);
     SendTEvGet(env, sender, groupId, blob.Id, mustRestoreFirst, isIndexOnly, forceBlockTabletData);
@@ -218,12 +218,12 @@ void SendTEvGet(TEnvironmentSetup& env, TActorId sender, ui32 groupId, std::vect
     });
 }
 
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> CaptureMultiTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {    
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> CaptureMultiTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvGetResult>(sender, termOnCapture, deadline);
     UNIT_ASSERT(res);
 
-#ifdef LOG_MULTIGET        
+#ifdef LOG_MULTIGET
     Cerr << "Response# " << res->Get()->ToString() << Endl;
 #endif
 
@@ -231,9 +231,9 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> CaptureMultiTEvGetResult(TE
 }
 
 
-void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res,
+void VerifyTEvGetResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> res,
         std::vector<TBlobInfo>& blobs, bool mustRestoreFirst, bool isIndexOnly, std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData,
-        TBSState& state) 
+        TBSState& state)
 {
     Y_UNUSED(mustRestoreFirst);
     Y_UNUSED(forceBlockTabletData);
@@ -248,8 +248,8 @@ void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res
             ui32 hardCollectGen = state[blobs[i].Id.TabletID()].Channels[blobs[i].Id.Channel()].HardCollectGen;
             ui32 hardCollectStep = state[blobs[i].Id.TabletID()].Channels[blobs[i].Id.Channel()].HardCollectStep;
             if ((blobs[i].Status == TBlobInfo::EStatus::COLLECTED) || IsCollected(blobs[i], softCollectGen, softCollectStep, hardCollectGen, hardCollectStep)) {
-                if (responses[i].Status == NKikimrProto::OK) { 
-                    Cerr << "Read over the barrier, blob id# " << responses[i].Id.ToString() << Endl; 
+                if (responses[i].Status == NKikimrProto::OK) {
+                    Cerr << "Read over the barrier, blob id# " << responses[i].Id.ToString() << Endl;
                 }
                 blobs[i].Status = TBlobInfo::EStatus::COLLECTED;
             } else if (blobs[i].Status == TBlobInfo::EStatus::WRITTEN) {
@@ -262,8 +262,8 @@ void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res
                     blobs[i].Status = TBlobInfo::EStatus::WRITTEN;
                 }
             } else {
-                if (responses[i].Status != NKikimrProto::NODATA) { 
-                    Cerr << "Read over the barrier, blob id# " << responses[i].Id.ToString() << Endl; 
+                if (responses[i].Status != NKikimrProto::NODATA) {
+                    Cerr << "Read over the barrier, blob id# " << responses[i].Id.ToString() << Endl;
                 }
             }
         }
@@ -271,7 +271,7 @@ void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res
 }
 
 void VerifiedGet(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, std::vector<TBlobInfo>& blobs, bool mustRestoreFirst, bool isIndexOnly, std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData,
-        TBSState& state, bool withDeadline) 
+        TBSState& state, bool withDeadline)
 {
     auto sender = env.Runtime->AllocateEdgeActor(nodeId);
     SendTEvGet(env, sender, groupId, blobs, mustRestoreFirst, isIndexOnly, forceBlockTabletData);
@@ -281,11 +281,11 @@ void VerifiedGet(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, std::vector<
     VerifyTEvGetResult(res.Release(), blobs, mustRestoreFirst, isIndexOnly, forceBlockTabletData, state);
 }
 
-void SendTEvRange(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, 
+void SendTEvRange(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId,
         TLogoBlobID from, TLogoBlobID to, bool mustRestoreFirst, bool indexOnly, ui64 cookie) {
     auto ev = new TEvBlobStorage::TEvRange(tabletId, from, to, mustRestoreFirst, TInstant::Max(), indexOnly);
 
-#ifdef LOG_RANGE        
+#ifdef LOG_RANGE
     Cerr << "Request# " << ev->ToString() << Endl;
 #endif
 
@@ -293,8 +293,8 @@ void SendTEvRange(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 ta
         SendToBSProxy(sender, groupId, ev, cookie);
     });
 }
-    
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>> CaptureTEvRangeResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
+
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvRangeResult>> CaptureTEvRangeResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvRangeResult>(sender, termOnCapture, deadline);
     UNIT_ASSERT(res);
@@ -308,8 +308,8 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>> CaptureTEvRangeResult(TEn
     return res.Release();
 }
 
-void VerifyTEvRangeResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>> res, ui64 tabletId, TLogoBlobID from, TLogoBlobID to, bool mustRestoreFirst, bool indexOnly,
-        std::vector<TBlobInfo>& blobs, TBSState& state) 
+void VerifyTEvRangeResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvRangeResult>> res, ui64 tabletId, TLogoBlobID from, TLogoBlobID to, bool mustRestoreFirst, bool indexOnly,
+        std::vector<TBlobInfo>& blobs, TBSState& state)
 {
     NKikimrProto::EReplyStatus status = res->Get()->Status;
     auto& responses = res->Get()->Responses;
@@ -359,7 +359,7 @@ void VerifyTEvRangeResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>>
             ui32 softCollectStep = state[blob.Id.TabletID()].Channels[blob.Id.Channel()].SoftCollectStep;
             ui32 hardCollectGen = state[blob.Id.TabletID()].Channels[blob.Id.Channel()].HardCollectGen;
             ui32 hardCollectStep = state[blob.Id.TabletID()].Channels[blob.Id.Channel()].HardCollectStep;
-            if ((blob.Status == TBlobInfo::EStatus::WRITTEN) &&  !IsCollected(blob, softCollectGen, softCollectStep, hardCollectGen, hardCollectStep) && 
+            if ((blob.Status == TBlobInfo::EStatus::WRITTEN) &&  !IsCollected(blob, softCollectGen, softCollectStep, hardCollectGen, hardCollectStep) &&
                 blob.Id >= from && blob.Id <= to && expected.find(blob.Id) == expected.end()) {
                 UNIT_FAIL(TStringBuilder() << "TEvRange didn't find blob " << blob.Id.ToString());
             }
@@ -367,18 +367,18 @@ void VerifyTEvRangeResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>>
     }
 }
 
-void VerifiedRange(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, TLogoBlobID from, TLogoBlobID to, 
-        bool mustRestoreFirst, bool indexOnly, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline) 
+void VerifiedRange(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, TLogoBlobID from, TLogoBlobID to,
+        bool mustRestoreFirst, bool indexOnly, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline)
 {
     auto sender = env.Runtime->AllocateEdgeActor(nodeId);
     SendTEvRange(env, sender, groupId, tabletId, from, to, mustRestoreFirst, indexOnly);
     auto res = CaptureTEvRangeResult(env, sender, true, withDeadline);
     VerifyTEvRangeResult(res.Release(), tabletId, from, to, mustRestoreFirst, indexOnly, blobs, state);
-}  
+}
 
-void SendTEvDiscover(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody, 
+void SendTEvDiscover(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody,
         bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, ui64 cookie) {
-    auto ev = new TEvBlobStorage::TEvDiscover(tabletId, minGeneration, readBody, discoverBlockedGeneration, 
+    auto ev = new TEvBlobStorage::TEvDiscover(tabletId, minGeneration, readBody, discoverBlockedGeneration,
             TInstant::Max(), forceBlockedGeneration, fromLeader);
 
 #ifdef LOG_DISCOVER
@@ -390,7 +390,7 @@ void SendTEvDiscover(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64
     });
 }
 
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvDiscoverResult>> CaptureTEvDiscoverResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvDiscoverResult>> CaptureTEvDiscoverResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvDiscoverResult>(sender, termOnCapture, deadline);
     UNIT_ASSERT(res);
@@ -402,8 +402,8 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvDiscoverResult>> CaptureTEvDiscoverResu
     return res.Release();
 }
 
-void VerifyTEvDiscoverResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvDiscoverResult>> res, ui64 tabletId, ui32 minGeneration, bool readBody, 
-        bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, std::vector<TBlobInfo>& blobs, TBSState& state) 
+void VerifyTEvDiscoverResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvDiscoverResult>> res, ui64 tabletId, ui32 minGeneration, bool readBody,
+        bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, std::vector<TBlobInfo>& blobs, TBSState& state)
 {
     ui32 blockedGen = state[tabletId].BlockedGen;
     Y_UNUSED(blockedGen);
@@ -464,7 +464,7 @@ void VerifyTEvDiscoverResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvDiscoverRe
     }
 }
 
-void VerifiedDiscover(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody, 
+void VerifiedDiscover(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody,
         bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline) {
     auto sender = env.Runtime->AllocateEdgeActor(nodeId);
     SendTEvDiscover(env, sender, groupId, tabletId, minGeneration, readBody, discoverBlockedGeneration, forceBlockedGeneration, fromLeader);
@@ -472,25 +472,25 @@ void VerifiedDiscover(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 ta
     VerifyTEvDiscoverResult(res.Release(), tabletId, minGeneration, readBody, discoverBlockedGeneration, forceBlockedGeneration, fromLeader, blobs, state);
 }
 
-void SendTEvCollectGarbage(TEnvironmentSetup& env, TActorId sender, ui32 groupId, 
+void SendTEvCollectGarbage(TEnvironmentSetup& env, TActorId sender, ui32 groupId,
     ui64 tabletId, ui32 recordGeneration, ui32 perGenerationCounter, ui32 channel,
     bool collect, ui32 collectGeneration,
     ui32 collectStep, TVector<TLogoBlobID> *keep, TVector<TLogoBlobID> *doNotKeep,
-    bool isMultiCollectAllowed, bool hard, ui64 cookie) 
+    bool isMultiCollectAllowed, bool hard, ui64 cookie)
 {
     auto ev = new TEvBlobStorage::TEvCollectGarbage(tabletId, recordGeneration, perGenerationCounter, channel, collect, collectGeneration, collectStep,
                 keep, doNotKeep, TInstant::Max(), isMultiCollectAllowed, hard);
-    
+
 #ifdef LOG_COLLECT_GARBAGE
     Cerr << "Request# " << ev->Print(false) << Endl;
 #endif
-    
+
     env.Runtime->WrapInActorContext(sender, [&] {
         SendToBSProxy(sender, groupId, ev, cookie);
     });
-}  
-    
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvCollectGarbageResult>> CaptureTEvCollectGarbageResult(TEnvironmentSetup& env, TActorId sender,
+}
+
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvCollectGarbageResult>> CaptureTEvCollectGarbageResult(TEnvironmentSetup& env, TActorId sender,
         bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvCollectGarbageResult>(sender, termOnCapture, deadline);
@@ -501,13 +501,13 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvCollectGarbageResult>> CaptureTEvCollec
 #endif
 
     return res.Release();
-} 
+}
 
-void VerifyTEvCollectGarbageResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvCollectGarbageResult>> res, 
+void VerifyTEvCollectGarbageResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvCollectGarbageResult>> res,
     ui64 tabletId, ui32 recordGeneration, ui32 perGenerationCounter, ui32 channel,
     bool collect, ui32 collectGeneration,
     ui32 collectStep, TVector<TLogoBlobID> *keep, TVector<TLogoBlobID> *doNotKeep,
-    bool isMultiCollectAllowed, bool hard, std::vector<TBlobInfo>& blobs, TBSState& state) 
+    bool isMultiCollectAllowed, bool hard, std::vector<TBlobInfo>& blobs, TBSState& state)
 {
     Y_UNUSED(perGenerationCounter);
     Y_UNUSED(isMultiCollectAllowed);
@@ -581,11 +581,11 @@ void VerifyTEvCollectGarbageResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvColl
     }
 }
 
-void VerifiedCollectGarbage(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, 
+void VerifiedCollectGarbage(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId,
     ui64 tabletId, ui32 recordGeneration, ui32 perGenerationCounter, ui32 channel,
     bool collect, ui32 collectGeneration,
     ui32 collectStep, TVector<TLogoBlobID> *keep, TVector<TLogoBlobID> *doNotKeep,
-    bool isMultiCollectAllowed, bool hard, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline) 
+    bool isMultiCollectAllowed, bool hard, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline)
 {
     auto sender = env.Runtime->AllocateEdgeActor(nodeId);
 
@@ -598,33 +598,33 @@ void VerifiedCollectGarbage(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId,
         copyDoNotKeep.Reset(new TVector(*doNotKeep));
     }
 
-    SendTEvCollectGarbage(env, sender, groupId, tabletId, recordGeneration, perGenerationCounter, channel, collect, 
+    SendTEvCollectGarbage(env, sender, groupId, tabletId, recordGeneration, perGenerationCounter, channel, collect,
             collectGeneration, collectStep, keep, doNotKeep, isMultiCollectAllowed, hard);
 
     auto res = CaptureTEvCollectGarbageResult(env, sender, true, withDeadline);
-    VerifyTEvCollectGarbageResult(res.Release(), tabletId, recordGeneration, perGenerationCounter, channel, collect, 
+    VerifyTEvCollectGarbageResult(res.Release(), tabletId, recordGeneration, perGenerationCounter, channel, collect,
         collectGeneration, collectStep, copyKeep.Get(), copyDoNotKeep.Get(), isMultiCollectAllowed, hard, blobs, state);
 }
 
 
 void SendTEvBlock(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, ui32 generation, ui64 cookie) {
     auto ev = new TEvBlobStorage::TEvBlock(tabletId, generation, TInstant::Max());
-    
+
 #ifdef LOG_BLOCK
     Cerr << "Request# " << ev->Print(true) << Endl;
 #endif
-    
+
     env.Runtime->WrapInActorContext(sender, [&] {
         SendToBSProxy(sender, groupId, ev, cookie);
     });
 }
 
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvBlockResult>> CaptureTEvBlockResult(TEnvironmentSetup& env, TActorId sender,
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvBlockResult>> CaptureTEvBlockResult(TEnvironmentSetup& env, TActorId sender,
         bool termOnCapture, bool withDeadline) {
     const TInstant deadline = MakeDeadline(env, withDeadline);
     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvBlockResult>(sender, termOnCapture, deadline);
     UNIT_ASSERT(res);
-    
+
 #ifdef LOG_BLOCK
     Cerr << "Response# " << res->Get()->ToString() << Endl;
 #endif
@@ -632,7 +632,7 @@ TAutoPtr<TEventHandle<TEvBlobStorage::TEvBlockResult>> CaptureTEvBlockResult(TEn
     return res.Release();
 }
 
-void VerifyTEvBlockResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvBlockResult>> res, ui64 tabletId, ui32 generation, TBSState& state) {
+void VerifyTEvBlockResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvBlockResult>> res, ui64 tabletId, ui32 generation, TBSState& state) {
     ui32& blockedGen = state[tabletId].BlockedGen;
     NKikimrProto::EReplyStatus status = res->Get()->Status;
     if (generation < blockedGen) {
diff --git a/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.h b/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.h
index 0a62ee8f503..674b060321b 100644
--- a/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.h
+++ b/ydb/core/blobstorage/ut_blobstorage/blob_depot_event_managers.h
@@ -11,16 +11,16 @@ std::unique_ptr<IEventHandle> CaptureAnyResult(TEnvironmentSetup& env, TActorId
 
 /* --------------------------------- PUT --------------------------------- */
 void SendTEvPut(TEnvironmentSetup& env, TActorId sender, ui32 groupId, TLogoBlobID id, TString data, ui64 cookie = 0);
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvPutResult>> CaptureTEvPutResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvPutResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvPutResult>> res, TBlobInfo& blob, TBSState& state);
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvPutResult>> CaptureTEvPutResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
+void VerifyTEvPutResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvPutResult>> res, TBlobInfo& blob, TBSState& state);
 void VerifiedPut(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, TBlobInfo& blob, TBSState& state, bool withDeadline = true);
 
 /* --------------------------------- GET --------------------------------- */
 void SendTEvGet(TEnvironmentSetup& env, TActorId sender, ui32 groupId, TLogoBlobID id,
         bool mustRestoreFirst = false, bool isIndexOnly = false,
         std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData = {}, ui64 cookie = 0);
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> CaptureTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res,
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> CaptureTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
+void VerifyTEvGetResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> res,
         TBlobInfo& blob, bool mustRestoreFirst, bool isIndexOnly,
         std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData, TBSState& state);
 void VerifiedGet(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, TBlobInfo& blob, bool mustRestoreFirst, bool isIndexOnly,
@@ -30,46 +30,46 @@ void VerifiedGet(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, TBlobInfo& b
 void SendTEvGet(TEnvironmentSetup& env, TActorId sender, ui32 groupId, std::vector<TBlobInfo>& blobs,
         bool mustRestoreFirst = false, bool isIndexOnly = false,
         std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData = {}, ui64 cookie = 0);
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> CaptureMultiTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvGetResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvGetResult>> res,
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> CaptureMultiTEvGetResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
+void VerifyTEvGetResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> res,
         std::vector<TBlobInfo>& blobs, bool mustRestoreFirst, bool isIndexOnly,
         std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData, TBSState& state);
 void VerifiedGet(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, std::vector<TBlobInfo>& blobs, bool mustRestoreFirst, bool isIndexOnly,
         std::optional<TEvBlobStorage::TEvGet::TForceBlockTabletData> forceBlockTabletData, TBSState& state, bool withDeadline = true);
 
 /* --------------------------------- RANGE --------------------------------- */
-void SendTEvRange(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, 
+void SendTEvRange(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId,
         TLogoBlobID from, TLogoBlobID to, bool mustRestoreFirst, bool indexOnly, ui64 cookie = 0);
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>> CaptureTEvRangeResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvRangeResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvRangeResult>> res, ui64 tabletId, TLogoBlobID from, TLogoBlobID to, bool mustRestoreFirst, bool indexOnly,
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvRangeResult>> CaptureTEvRangeResult(TEnvironmentSetup& env, TActorId sender, bool termOnCapture = true, bool withDeadline = true);
+void VerifyTEvRangeResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvRangeResult>> res, ui64 tabletId, TLogoBlobID from, TLogoBlobID to, bool mustRestoreFirst, bool indexOnly,
         std::vector<TBlobInfo>& blobs, TBSState& state);
-void VerifiedRange(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, TLogoBlobID from, TLogoBlobID to, 
+void VerifiedRange(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, TLogoBlobID from, TLogoBlobID to,
         bool mustRestoreFirst, bool indexOnly, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline = true);
 
 /* --------------------------------- DISCOVER --------------------------------- */
-void SendTEvDiscover(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody, 
+void SendTEvDiscover(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody,
         bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, ui64 cookie = 0);
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvDiscoverResult>> CaptureTEvDiscoverResult(TEnvironmentSetup& env, TActorId sender, 
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvDiscoverResult>> CaptureTEvDiscoverResult(TEnvironmentSetup& env, TActorId sender,
         bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvDiscoverResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvDiscoverResult>> res, ui64 tabletId, ui32 minGeneration, bool readBody, 
+void VerifyTEvDiscoverResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvDiscoverResult>> res, ui64 tabletId, ui32 minGeneration, bool readBody,
         bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, std::vector<TBlobInfo>& blobs, TBSState& state);
-void VerifiedDiscover(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody, 
+void VerifiedDiscover(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, ui32 minGeneration, bool readBody,
         bool discoverBlockedGeneration, ui32 forceBlockedGeneration, bool fromLeader, std::vector<TBlobInfo>& blobs, TBSState& state, bool withDeadline = true);
 
 /* --------------------------------- COLLECT GARBAGE --------------------------------- */
-void SendTEvCollectGarbage(TEnvironmentSetup& env, TActorId sender, ui32 groupId, 
+void SendTEvCollectGarbage(TEnvironmentSetup& env, TActorId sender, ui32 groupId,
     ui64 tabletId, ui32 recordGeneration, ui32 perGenerationCounter, ui32 channel,
     bool collect, ui32 collectGeneration,
     ui32 collectStep, TVector<TLogoBlobID> *keep, TVector<TLogoBlobID> *doNotKeep,
-    bool isMultiCollectAllowed, bool hard, ui64 cookie = 0); 
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvCollectGarbageResult>> CaptureTEvCollectGarbageResult(TEnvironmentSetup& env, TActorId sender,
+    bool isMultiCollectAllowed, bool hard, ui64 cookie = 0);
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvCollectGarbageResult>> CaptureTEvCollectGarbageResult(TEnvironmentSetup& env, TActorId sender,
         bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvCollectGarbageResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvCollectGarbageResult>> res, 
+void VerifyTEvCollectGarbageResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvCollectGarbageResult>> res,
     ui64 tabletId, ui32 recordGeneration, ui32 perGenerationCounter, ui32 channel,
     bool collect, ui32 collectGeneration,
     ui32 collectStep, TVector<TLogoBlobID> *keep, TVector<TLogoBlobID> *doNotKeep,
     bool isMultiCollectAllowed, bool hard, std::vector<TBlobInfo>& blobs, TBSState& state);
-void VerifiedCollectGarbage(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, 
+void VerifiedCollectGarbage(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId,
     ui64 tabletId, ui32 recordGeneration, ui32 perGenerationCounter, ui32 channel,
     bool collect, ui32 collectGeneration,
     ui32 collectStep, TVector<TLogoBlobID> *keep, TVector<TLogoBlobID> *doNotKeep,
@@ -77,7 +77,7 @@ void VerifiedCollectGarbage(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId,
 
 /* --------------------------------- BLOCK --------------------------------- */
 void SendTEvBlock(TEnvironmentSetup& env, TActorId sender, ui32 groupId, ui64 tabletId, ui32 generation, ui64 cookie = 0);
-TAutoPtr<TEventHandle<TEvBlobStorage::TEvBlockResult>> CaptureTEvBlockResult(TEnvironmentSetup& env, TActorId sender, 
+TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvBlockResult>> CaptureTEvBlockResult(TEnvironmentSetup& env, TActorId sender,
         bool termOnCapture = true, bool withDeadline = true);
-void VerifyTEvBlockResult(TAutoPtr<TEventHandle<TEvBlobStorage::TEvBlockResult>> res, ui64 tabletId, ui32 generation, TBSState& state);
+void VerifyTEvBlockResult(TAutoPtr<TEventHandleFat<TEvBlobStorage::TEvBlockResult>> res, ui64 tabletId, ui32 generation, TBSState& state);
 void VerifiedBlock(TEnvironmentSetup& env, ui32 nodeId, ui32 groupId, ui64 tabletId, ui32 generation, TBSState& state, bool withDeadline = true);
diff --git a/ydb/core/blobstorage/ut_blobstorage/blob_depot_test_functions.cpp b/ydb/core/blobstorage/ut_blobstorage/blob_depot_test_functions.cpp
index f36043daf8a..e250458068e 100644
--- a/ydb/core/blobstorage/ut_blobstorage/blob_depot_test_functions.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/blob_depot_test_functions.cpp
@@ -66,7 +66,7 @@ TLogoBlobID MaxBlobID(ui64 tablet) {
         NKikimr::TLogoBlobID::MaxCrcMode);
 }
 
-void TestBasicRange(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 groupId) { 
+void TestBasicRange(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 groupId) {
     std::vector<TBlobInfo> blobs;
     TBSState state;
     state[tabletId];
@@ -172,7 +172,7 @@ void TestBasicBlock(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 groupId
     VerifiedGet(*tenv.Env, 1, groupId, blobs[7], false, false, std::nullopt, state);
 }
 
-void TestBasicCollectGarbage(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 groupId) {    
+void TestBasicCollectGarbage(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 groupId) {
     std::vector<TBlobInfo> blobs;
     ui64 tablet2 = tabletId + 1;
     TBSState state;
@@ -239,7 +239,7 @@ void TestBasicCollectGarbage(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui3
         TBlobInfo blob(tenv.DataGen(100), tabletId, 99, 1, 3, 0);
         VerifiedPut(*tenv.Env, 1, groupId, blob, state);
         blobs.push_back(blob);
-    } 
+    }
     VerifiedRange(*tenv.Env, 1, groupId, tabletId, blobs[1].Id, blobs[1].Id, false, false, blobs, state);
 
     VerifiedGet(*tenv.Env, 1, groupId, blobs[1], false, false, std::nullopt, state);
@@ -249,22 +249,22 @@ void TestBasicCollectGarbage(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui3
     VerifiedGet(*tenv.Env, 1, groupId, blobs[20], false, false, std::nullopt, state);
     VerifiedGet(*tenv.Env, 1, groupId, blobs[30], false, false, std::nullopt, state);
     VerifiedGet(*tenv.Env, 1, groupId, blobs[31], false, false, std::nullopt, state);
-    VerifiedGet(*tenv.Env, 1, groupId, blobs[40], false, false, std::nullopt, state); 
+    VerifiedGet(*tenv.Env, 1, groupId, blobs[40], false, false, std::nullopt, state);
 
     VerifiedCollectGarbage(*tenv.Env, 1, groupId, tabletId, gen, perGenCtr++, 0, true, 1, 1, nullptr, nullptr, false, true, blobs, state);
 
-    VerifiedCollectGarbage(*tenv.Env, 1, groupId, tabletId, gen, perGenCtr++, 0, false, 1, 5, 
-            new TVector<TLogoBlobID>({blobs[4].Id, blobs[5].Id}), 
-            nullptr, 
+    VerifiedCollectGarbage(*tenv.Env, 1, groupId, tabletId, gen, perGenCtr++, 0, false, 1, 5,
+            new TVector<TLogoBlobID>({blobs[4].Id, blobs[5].Id}),
+            nullptr,
             false, false,
             blobs, state);
 
     VerifiedGet(*tenv.Env, 1, groupId, blobs[4], false, false, std::nullopt, state);
     VerifiedGet(*tenv.Env, 1, groupId, blobs[5], false, false, std::nullopt, state);
 
-    VerifiedCollectGarbage(*tenv.Env, 1, groupId, tabletId, gen, perGenCtr++, 0, false, 1, 6, 
-            nullptr, 
-            new TVector<TLogoBlobID>({blobs[4].Id, blobs[5].Id}), 
+    VerifiedCollectGarbage(*tenv.Env, 1, groupId, tabletId, gen, perGenCtr++, 0, false, 1, 6,
+            nullptr,
+            new TVector<TLogoBlobID>({blobs[4].Id, blobs[5].Id}),
             false, false,
             blobs, state);
     VerifiedGet(*tenv.Env, 1, groupId, blobs[4], false, false, std::nullopt, state);
@@ -272,7 +272,7 @@ void TestBasicCollectGarbage(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui3
 
 
     VerifiedCollectGarbage(*tenv.Env, 1, groupId, tabletId, gen, perGenCtr++, 0, true, 1, 15, nullptr, nullptr, false, true, blobs, state);
-    
+
     VerifiedRange(*tenv.Env, 1, groupId, tabletId, blobs[10].Id, blobs[19].Id, false, false, blobs, state);
 
     gen++;
@@ -321,7 +321,7 @@ void TestRestoreGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 groupId
         }
         return true;
     };
-    
+
     for (ui32 i = 0; i < blobsNum; ++i) {
         blobs.push_back(TBlobInfo(tenv.DataGen(100), tabletId, 1 + i, 1, 1, 0));
     }
@@ -430,7 +430,7 @@ void TestRestoreRange(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 group
         blobs.push_back(TBlobInfo(tenv.DataGen(100), tabletId, tenv.Rand(NKikimr::TLogoBlobID::MaxCookie), 1, 1 + i, 0));
         VerifiedPut(*tenv.Env, 1, groupId, blobs[i], state);
     }
-    
+
     blockedEventType = TEvBlobStorage::TEvVGet::EventType;
     brokenVdisks = { allVdisks[0], allVdisks[1] };
 
@@ -507,7 +507,7 @@ void TestVerifiedRandom(TBlobDepotTestEnvironment& tenv, ui32 nodeCount, ui64 ta
         ui32 softCollectStep = state[tabletId].Channels[channel].SoftCollectStep;
         ui32 hardCollectGen = state[tabletId].Channels[channel].HardCollectGen;
         ui32 hardCollectStep = state[tabletId].Channels[channel].HardCollectStep;
-        
+
         ui32 action = act.GetInterval(tenv.Rand(act.UpperLimit()));
         // Cerr << "iteration# " << iteration << " action# " << actionName[action] << " timer# " << timer.Passed() << Endl;
         switch (action) {
@@ -597,7 +597,7 @@ void TestVerifiedRandom(TBlobDepotTestEnvironment& tenv, ui32 nodeCount, ui64 ta
                 ui32 minGeneration = tenv.Rand(0, gen + 2);
                 bool readBody = tenv.Rand(2);
                 bool discoverBlockedGeneration = tenv.Rand(2);
-                ui32 forceBlockedGeneration = 0; 
+                ui32 forceBlockedGeneration = 0;
                 bool fromLeader = tenv.Rand(2);
 
                 VerifiedDiscover(*tenv.Env, node, groupId, tabletId, minGeneration, readBody, discoverBlockedGeneration, forceBlockedGeneration,
@@ -634,10 +634,10 @@ void TestVerifiedRandom(TBlobDepotTestEnvironment& tenv, ui32 nodeCount, ui64 ta
                 }
 
                 if (keep->size() == 0 && doNotKeep->size() == 0) {
-                    collect = true; 
+                    collect = true;
                 }
 
-                VerifiedCollectGarbage(*tenv.Env, node, groupId, tabletId, gen, perGenCtr++, channel, collect, 
+                VerifiedCollectGarbage(*tenv.Env, node, groupId, tabletId, gen, perGenCtr++, channel, collect,
                     tryGen, tryStep, keep.Release(), doNotKeep.Release(), isMultiCollectAllowed, true, blobs, state);
             }
             break;
@@ -671,10 +671,10 @@ void TestVerifiedRandom(TBlobDepotTestEnvironment& tenv, ui32 nodeCount, ui64 ta
                 }
 
                 if (keep->size() == 0 && doNotKeep->size() == 0) {
-                    collect = true; 
+                    collect = true;
                 }
 
-                VerifiedCollectGarbage(*tenv.Env, node, groupId, tabletId, gen, perGenCtr++, channel, collect, 
+                VerifiedCollectGarbage(*tenv.Env, node, groupId, tabletId, gen, perGenCtr++, channel, collect,
                     tryGen, tryStep, keep.Release(), doNotKeep.Release(), isMultiCollectAllowed, false, blobs, state);
             }
             break;
@@ -688,7 +688,7 @@ void TestVerifiedRandom(TBlobDepotTestEnvironment& tenv, ui32 nodeCount, ui64 ta
             }
             break;
 
-        default: 
+        default:
             UNIT_FAIL("TIntervals failed");
         }
     }
@@ -807,7 +807,7 @@ void TestLoadPutAndGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 grou
                 ui32 minGeneration = 0;
                 bool readBody = tenv.Rand(2);
                 bool discoverBlockedGeneration = tenv.Rand(2);
-                ui32 forceBlockedGeneration = 0; 
+                ui32 forceBlockedGeneration = 0;
                 bool fromLeader = tenv.Rand(2);
 
                 SendTEvDiscover(*tenv.Env, edge, groupId, tabletId, minGeneration, readBody, discoverBlockedGeneration, forceBlockedGeneration,
@@ -817,7 +817,7 @@ void TestLoadPutAndGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 grou
             }
             break;
 
-        case EActions::CATCH_ALL: 
+        case EActions::CATCH_ALL:
             {
                 // Cerr << getCtr << ' ' << rangeCtr << ' ' << discoverCtr << Endl;
                 while (getCtr + rangeCtr + discoverCtr) {
@@ -826,7 +826,7 @@ void TestLoadPutAndGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 grou
                     switch (ev->GetTypeRewrite()) {
                     case TEvBlobStorage::TEvGetResult::EventType:
                         {
-                            std::unique_ptr<TEventHandle<TEvBlobStorage::TEvGetResult>> res(reinterpret_cast<TEventHandle<TEvBlobStorage::TEvGetResult>*>(ev.release()));
+                            std::unique_ptr<TEventHandleFat<TEvBlobStorage::TEvGetResult>> res(reinterpret_cast<TEventHandleFat<TEvBlobStorage::TEvGetResult>*>(ev.release()));
                             UNIT_ASSERT(res);
                             std::vector<TBlobInfo> response;
                             ui32 responseSz = res->Get()->ResponseSz;
@@ -840,7 +840,7 @@ void TestLoadPutAndGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 grou
                         break;
                     case TEvBlobStorage::TEvRangeResult::EventType:
                         {
-                            std::unique_ptr<TEventHandle<TEvBlobStorage::TEvRangeResult>> res(reinterpret_cast<TEventHandle<TEvBlobStorage::TEvRangeResult>*>(ev.release()));
+                            std::unique_ptr<TEventHandleFat<TEvBlobStorage::TEvRangeResult>> res(reinterpret_cast<TEventHandleFat<TEvBlobStorage::TEvRangeResult>*>(ev.release()));
                             UNIT_ASSERT(res);
                             TLogoBlobID from = res->Get()->From;
                             TLogoBlobID to = res->Get()->To;
@@ -851,7 +851,7 @@ void TestLoadPutAndGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 grou
                         break;
                     case TEvBlobStorage::TEvDiscoverResult::EventType:
                         {
-                            std::unique_ptr<TEventHandle<TEvBlobStorage::TEvDiscoverResult>> res(reinterpret_cast<TEventHandle<TEvBlobStorage::TEvDiscoverResult>*>(ev.release()));
+                            std::unique_ptr<TEventHandleFat<TEvBlobStorage::TEvDiscoverResult>> res(reinterpret_cast<TEventHandleFat<TEvBlobStorage::TEvDiscoverResult>*>(ev.release()));
                             UNIT_ASSERT(res);
                             UNIT_ASSERT(res->Get());
                             TEvDiscoverArgs args = *requests[res->Cookie]->Get<TEvDiscoverArgs>();
@@ -874,7 +874,7 @@ void TestLoadPutAndGet(TBlobDepotTestEnvironment& tenv, ui64 tabletId, ui32 grou
             }
             break;
 
-        default: 
+        default:
             UNIT_FAIL("TIntervals failed");
         }
     }
diff --git a/ydb/core/blobstorage/ut_blobstorage/block_race.cpp b/ydb/core/blobstorage/ut_blobstorage/block_race.cpp
index 7d32a8bdf3a..60c1b9a25aa 100644
--- a/ydb/core/blobstorage/ut_blobstorage/block_race.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/block_race.cpp
@@ -20,7 +20,7 @@ Y_UNIT_TEST_SUITE(BlobStorageBlockRace) {
 
             env.WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](const TActorId& queueId) {
                 const TActorId edge = runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-                runtime->Send(new IEventHandle(queueId, edge, new TEvBlobStorage::TEvVBlock(tabletId, 1, vdiskId,
+                runtime->Send(new IEventHandleFat(queueId, edge, new TEvBlobStorage::TEvVBlock(tabletId, 1, vdiskId,
                     TInstant::Max(), guid)), edge.NodeId());
                 auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVBlockResult>(edge);
                 status = res->Get()->Record.GetStatus();
@@ -84,7 +84,7 @@ Y_UNIT_TEST_SUITE(BlobStorageBlockRace) {
 
         auto issue = [&](ui32 begin, ui32 end, ui64 guid) {
             for (ui32 i = begin; i < end; ++i) {
-                env.Runtime->Send(new IEventHandle(queues[i], edge, new TEvBlobStorage::TEvVBlock(tabletId, generation,
+                env.Runtime->Send(new IEventHandleFat(queues[i], edge, new TEvBlobStorage::TEvVBlock(tabletId, generation,
                     info->GetVDiskId(i), TInstant::Max(), guid)), edge.NodeId());
                 ++responsesPending;
             }
@@ -170,7 +170,7 @@ Y_UNIT_TEST_SUITE(BlobStorageBlockRace) {
 
         auto issue = [&](ui32 begin, ui32 end, ui64 guid) {
             for (ui32 i = begin; i < end; ++i) {
-                env.Runtime->Send(new IEventHandle(queues[i], edge, new TEvBlobStorage::TEvVBlock(tabletId, generation,
+                env.Runtime->Send(new IEventHandleFat(queues[i], edge, new TEvBlobStorage::TEvVBlock(tabletId, generation,
                     info->GetVDiskId(i), TInstant::Max(), guid)), edge.NodeId());
             }
         };
diff --git a/ydb/core/blobstorage/ut_blobstorage/defrag.cpp b/ydb/core/blobstorage/ut_blobstorage/defrag.cpp
index f17f60066c5..7b67d5afa35 100644
--- a/ydb/core/blobstorage/ut_blobstorage/defrag.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/defrag.cpp
@@ -77,7 +77,7 @@ static TIntrusivePtr<TBlobStorageGroupInfo> PrepareEnv(TEnvironmentSetup& env, T
         // trigger compaction
         {
             const auto& sender = env.Runtime->AllocateEdgeActor(actorId.NodeId());
-            auto ev = std::make_unique<IEventHandle>(actorId, sender, TEvCompactVDisk::Create(EHullDbType::LogoBlobs));
+            auto ev = std::make_unique<IEventHandleFat>(actorId, sender, TEvCompactVDisk::Create(EHullDbType::LogoBlobs));
             ev->Rewrite(TEvBlobStorage::EvForwardToSkeleton, actorId);
             env.Runtime->Send(ev.release(), sender.NodeId());
             auto res = env.WaitForEdgeActorEvent<TEvCompactVDiskResult>(sender);
diff --git a/ydb/core/blobstorage/ut_blobstorage/donor.cpp b/ydb/core/blobstorage/ut_blobstorage/donor.cpp
index f0c7826e289..c898ac6c2e2 100644
--- a/ydb/core/blobstorage/ut_blobstorage/donor.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/donor.cpp
@@ -210,7 +210,7 @@ Y_UNIT_TEST_SUITE(Donor) {
                     for (const auto& id : writer->Data) {
                         auto ev = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(info->GetVDiskId(i), TInstant::Max(),
                             NKikimrBlobStorage::FastRead, {}, {}, {id});
-                        runtime.Send(new IEventHandle(queueId, edge, ev.release()), queueId.NodeId());
+                        runtime.Send(new IEventHandleFat(queueId, edge, ev.release()), queueId.NodeId());
                         auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge, false);
                         UNIT_ASSERT_VALUES_EQUAL(res->Get()->Record.GetStatus(), NKikimrProto::OK);
                         for (const auto& item : res->Get()->Record.GetResult()) {
@@ -220,7 +220,7 @@ Y_UNIT_TEST_SUITE(Donor) {
                             }
                         }
                     }
-                    runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
+                    runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
                 }
                 for (const auto& id : writer->Data) {
                     UNIT_ASSERT(parts[id] >= 6);
@@ -230,7 +230,7 @@ Y_UNIT_TEST_SUITE(Donor) {
                 resumePending = true;
             } else {
                 if (resumePending) {
-                    runtime.Send(new IEventHandle(TEvents::TSystem::Bootstrap, 0, writerId, {}, nullptr, 0), 1);
+                    runtime.Send(new IEventHandleFat(TEvents::TSystem::Bootstrap, 0, writerId, {}, nullptr, 0), 1);
                     resumePending = false;
                     env.Sim(TDuration::MilliSeconds(RandomNumber(1000u)));
                 }
@@ -278,7 +278,7 @@ Y_UNIT_TEST_SUITE(Donor) {
 
         env.Runtime->FilterFunction = [&](ui32 nodeId, std::unique_ptr<IEventHandle>& ev) {
             if (ev->GetTypeRewrite() == TEvBlobStorage::EvDropDonor) {
-                env.Runtime->Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected).Release(), nodeId);
+                env.Runtime->Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected).Release(), nodeId);
                 return false;
             }
             return true;
@@ -311,7 +311,7 @@ Y_UNIT_TEST_SUITE(Donor) {
                     Cerr << slot.DonorsSize() << " donors: " << printDonorList(slot) << Endl;
                     for (const auto& donor : slot.GetDonors()) {
                         const auto& vslotId = donor.GetVSlotId();
-                        UNIT_ASSERT_C(pdisks.emplace(vslotId.GetNodeId(), vslotId.GetPDiskId()).second, 
+                        UNIT_ASSERT_C(pdisks.emplace(vslotId.GetNodeId(), vslotId.GetPDiskId()).second,
                                 slot.DonorsSize() << " donors: " << printDonorList(slot));
                     }
                     break;
diff --git a/ydb/core/blobstorage/ut_blobstorage/gc_quorum_3dc.cpp b/ydb/core/blobstorage/ut_blobstorage/gc_quorum_3dc.cpp
index 6f48632a0a1..3fbd2aa50a1 100644
--- a/ydb/core/blobstorage/ut_blobstorage/gc_quorum_3dc.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/gc_quorum_3dc.cpp
@@ -79,7 +79,7 @@ Y_UNIT_TEST_SUITE(Mirror3dc) {
 
                     const TActorId queueId = queueIds[i];
                     const TActorId edge = getEdgeActor(queueId.NodeId());
-                    runtime->Send(new IEventHandle(queueId, edge, query.release()), edge.NodeId());
+                    runtime->Send(new IEventHandleFat(queueId, edge, query.release()), edge.NodeId());
                     auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge, false);
 
                     const auto& record = res->Get()->Record;
@@ -120,7 +120,7 @@ Y_UNIT_TEST_SUITE(Mirror3dc) {
                 const TActorId queueId = queueIds[diskIdx];
                 const TActorId edge = getEdgeActor(queueId.NodeId());
                 const TLogoBlobID& id = ids[j];
-                runtime->Send(new IEventHandle(queueId, edge, new TEvBlobStorage::TEvVCollectGarbage(id.TabletID(),
+                runtime->Send(new IEventHandleFat(queueId, edge, new TEvBlobStorage::TEvVCollectGarbage(id.TabletID(),
                     id.Generation(), 0, id.Channel(), true, id.Generation(), id.Step(), false, nullptr, nullptr, vdiskId,
                     TInstant::Max())), edge.NodeId());
                 ++waitQueue[edge];
diff --git a/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp b/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
index 7e1d7e66c82..8b8e2ee06fa 100644
--- a/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
@@ -28,7 +28,7 @@ Y_UNIT_TEST_SUITE(IncorrectQueries) {
 
         env.WithQueueId(test.Info->GetVDiskInSubgroup(0, blobId.Hash()), NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
             test.Edge = test.Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            test.Runtime->Send(new IEventHandle(queueId, test.Edge, ev.release()), queueId.NodeId());
+            test.Runtime->Send(new IEventHandleFat(queueId, test.Edge, ev.release()), queueId.NodeId());
             auto handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
             UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvVPutResult);
             TEvBlobStorage::TEvVPutResult *putResult = handle->Get<TEvBlobStorage::TEvVPutResult>();
@@ -55,7 +55,7 @@ Y_UNIT_TEST_SUITE(IncorrectQueries) {
 
         env.WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::GetFastRead, [&](TActorId queueId) {
             test.Edge = test.Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            test.Runtime->Send(new IEventHandle(queueId, test.Edge, ev.release()), queueId.NodeId());
+            test.Runtime->Send(new IEventHandleFat(queueId, test.Edge, ev.release()), queueId.NodeId());
             auto r = test.Runtime->WaitForEdgeActorEvent({test.Edge});
 
             UNIT_ASSERT_EQUAL(r->Type, TEvBlobStorage::EvVGetResult);
@@ -87,7 +87,7 @@ Y_UNIT_TEST_SUITE(IncorrectQueries) {
 
         env.WithQueueId(test.Info->GetVDiskId(0), NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
             test.Edge = test.Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            test.Runtime->Send(new IEventHandle(queueId, test.Edge, ev.release()), queueId.NodeId());
+            test.Runtime->Send(new IEventHandleFat(queueId, test.Edge, ev.release()), queueId.NodeId());
             auto handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
             UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvVMultiPutResult);
             TEvBlobStorage::TEvVMultiPutResult *putResult = handle->Get<TEvBlobStorage::TEvVMultiPutResult>();
@@ -110,7 +110,7 @@ Y_UNIT_TEST_SUITE(IncorrectQueries) {
 
         env.WithQueueId(test.Info->GetVDiskInSubgroup(0, blobs[0].BlobId.Hash()), NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
             test.Edge = test.Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            test.Runtime->Send(new IEventHandle(queueId, test.Edge, ev.release()), queueId.NodeId());
+            test.Runtime->Send(new IEventHandleFat(queueId, test.Edge, ev.release()), queueId.NodeId());
             auto handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
             UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvVMultiPutResult);
             TEvBlobStorage::TEvVMultiPutResult *putResult = handle->Get<TEvBlobStorage::TEvVMultiPutResult>();
@@ -421,7 +421,7 @@ Y_UNIT_TEST_SUITE(IncorrectQueries) {
 
         env.WithQueueId(test.Info->GetVDiskId(0), NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
             test.Edge = test.Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            test.Runtime->Send(new IEventHandle(queueId, test.Edge, ev.release()), queueId.NodeId());
+            test.Runtime->Send(new IEventHandleFat(queueId, test.Edge, ev.release()), queueId.NodeId());
             auto handle = test.Runtime->WaitForEdgeActorEvent({test.Edge});
             UNIT_ASSERT_EQUAL(handle->Type, TEvBlobStorage::EvVMultiPutResult);
             TEvBlobStorage::TEvVMultiPutResult *putResult = handle->Get<TEvBlobStorage::TEvVMultiPutResult>();
@@ -535,7 +535,7 @@ Y_UNIT_TEST_SUITE(IncorrectQueries) {
         env.WithQueueId(test.Info->GetVDiskId(0), NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
             test.Edge = test.Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
             for(int i = 0; i < eventsCount; ++i) {
-                test.Runtime->Send(new IEventHandle(queueId, test.Edge, events[i].release()), queueId.NodeId());
+                test.Runtime->Send(new IEventHandleFat(queueId, test.Edge, events[i].release()), queueId.NodeId());
             }
 
             int okCount = 0;
diff --git a/ydb/core/blobstorage/ut_blobstorage/lib/activity.h b/ydb/core/blobstorage/ut_blobstorage/lib/activity.h
index 8c6f3bfd486..75dfa731a1c 100644
--- a/ydb/core/blobstorage/ut_blobstorage/lib/activity.h
+++ b/ydb/core/blobstorage/ut_blobstorage/lib/activity.h
@@ -186,7 +186,7 @@ public:
     }
 
     void Handle(TEvents::TEvPoison::TPtr ev) {
-        TActivationContext::Send(new IEventHandle(EvFinished, 0, ev->Sender, SelfId(), {}, 0));
+        TActivationContext::Send(new IEventHandleFat(EvFinished, 0, ev->Sender, SelfId(), {}, 0));
         PassAway();
     }
 
diff --git a/ydb/core/blobstorage/ut_blobstorage/lib/env.h b/ydb/core/blobstorage/ut_blobstorage/lib/env.h
index df479806c0f..9b2a4b6d8ec 100644
--- a/ydb/core/blobstorage/ut_blobstorage/lib/env.h
+++ b/ydb/core/blobstorage/ut_blobstorage/lib/env.h
@@ -170,14 +170,14 @@ struct TEnvironmentSetup {
     }
 
     template<typename TEvent>
-    TAutoPtr<TEventHandle<TEvent>> WaitForEdgeActorEvent(const TActorId& actorId, bool termOnCapture = true,
+    TAutoPtr<TEventHandleFat<TEvent>> WaitForEdgeActorEvent(const TActorId& actorId, bool termOnCapture = true,
             TInstant deadline = TInstant::Max()) {
         std::set<TActorId> ids{actorId};
 
         TActorId wakeup;
         if (deadline != TInstant::Max()) {
             wakeup = Runtime->AllocateEdgeActor(actorId.NodeId(), __FILE__, __LINE__);
-            Runtime->Schedule(deadline, new IEventHandle(TEvents::TSystem::Wakeup, 0, wakeup, {}, nullptr, 0), nullptr,
+            Runtime->Schedule(deadline, new IEventHandleFat(TEvents::TSystem::Wakeup, 0, wakeup, {}, nullptr, 0), nullptr,
                 wakeup.NodeId());
             ids.insert(wakeup);
         }
@@ -188,7 +188,7 @@ struct TEnvironmentSetup {
                 Runtime->DestroyActor(wakeup);
                 return nullptr;
             } else if (ev->GetTypeRewrite() == TEvent::EventType) {
-                TAutoPtr<TEventHandle<TEvent>> res = reinterpret_cast<TEventHandle<TEvent>*>(ev.release());
+                TAutoPtr<TEventHandleFat<TEvent>> res = reinterpret_cast<TEventHandleFat<TEvent>*>(ev.release());
                 if (termOnCapture) {
                     Runtime->DestroyActor(actorId);
                 }
@@ -507,7 +507,7 @@ struct TEnvironmentSetup {
         const ui32 nodeId = actorId.NodeId();
         const TActorId& edge = Runtime->AllocateEdgeActor(nodeId, __FILE__, __LINE__);
         for (;;) {
-            Runtime->Send(new IEventHandle(actorId, edge, new TEvBlobStorage::TEvVStatus(vdiskId),
+            Runtime->Send(new IEventHandleFat(actorId, edge, new TEvBlobStorage::TEvVStatus(vdiskId),
                 IEventHandle::FlagTrackDelivery), nodeId);
             auto r = Runtime->WaitForEdgeActorEvent({edge});
             if (auto *msg = r->CastAsLocal<TEvBlobStorage::TEvVStatusResult>(); msg && msg->Record.GetReplicated()) {
@@ -521,7 +521,7 @@ struct TEnvironmentSetup {
     void CompactVDisk(const TActorId& actorId, bool freshOnly = false) {
         const TActorId& edge = Runtime->AllocateEdgeActor(actorId.NodeId());
         for (;;) {
-            Runtime->Send(new IEventHandle(actorId, edge, TEvCompactVDisk::Create(EHullDbType::LogoBlobs, freshOnly ?
+            Runtime->Send(new IEventHandleFat(actorId, edge, TEvCompactVDisk::Create(EHullDbType::LogoBlobs, freshOnly ?
                 TEvCompactVDisk::EMode::FRESH_ONLY : TEvCompactVDisk::EMode::FULL)), actorId.NodeId());
             auto res = Runtime->WaitForEdgeActorEvent({edge});
             if (res->GetTypeRewrite() == TEvents::TSystem::Undelivered) {
@@ -541,7 +541,7 @@ struct TEnvironmentSetup {
 
     TString Dump(const TActorId& vdiskActorId, const TVDiskID& vdiskId) {
         const TActorId& edge = Runtime->AllocateEdgeActor(vdiskActorId.NodeId(), __FILE__, __LINE__);
-        Runtime->Send(new IEventHandle(vdiskActorId, edge, new TEvBlobStorage::TEvVDbStat(vdiskId,
+        Runtime->Send(new IEventHandleFat(vdiskActorId, edge, new TEvBlobStorage::TEvVDbStat(vdiskId,
             NKikimrBlobStorage::EDbStatAction::DumpDb, NKikimrBlobStorage::EDbStatType::StatLogoBlobs,
             true)), edge.NodeId());
         return WaitForEdgeActorEvent<TEvBlobStorage::TEvVDbStatResult>(edge)->Get()->Record.GetData();
@@ -550,14 +550,14 @@ struct TEnvironmentSetup {
     void WithQueueId(const TVDiskID& vdiskId, NKikimrBlobStorage::EVDiskQueueId queue, std::function<void(TActorId)> action) {
         const TActorId& queueId = CreateQueueActor(vdiskId, queue, 1000);
         action(queueId);
-        Runtime->Send(new IEventHandle(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
+        Runtime->Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
     }
 
     void CheckBlob(const TActorId& vdiskActorId, const TVDiskID& vdiskId, const TLogoBlobID& blobId, const TString& part,
             NKikimrProto::EReplyStatus status = NKikimrProto::OK) {
         WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::GetFastRead, [&](TActorId queueId) {
             const TActorId& edge = Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            Runtime->Send(new IEventHandle(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(vdiskId,
+            Runtime->Send(new IEventHandleFat(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(vdiskId,
                 TInstant::Max(), NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None,
                 Nothing(), {{blobId, 1u, ui32(part.size() - 2)}}).release()), queueId.NodeId());
             auto r = WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge, false);
@@ -572,7 +572,7 @@ struct TEnvironmentSetup {
                 }
             }
 
-            Runtime->Send(new IEventHandle(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeIndexQuery(vdiskId,
+            Runtime->Send(new IEventHandleFat(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeIndexQuery(vdiskId,
                 TInstant::Max(), NKikimrBlobStorage::EGetHandleClass::FastRead, TEvBlobStorage::TEvVGet::EFlags::None,
                 Nothing(), {{blobId.FullID(), 0, 0}}).release()), queueId.NodeId());
             r = WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge);
@@ -591,7 +591,7 @@ struct TEnvironmentSetup {
     void PutBlob(const TVDiskID& vdiskId, const TLogoBlobID& blobId, const TString& part) {
         WithQueueId(vdiskId, NKikimrBlobStorage::EVDiskQueueId::PutTabletLog, [&](TActorId queueId) {
             const TActorId& edge = Runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-            Runtime->Send(new IEventHandle(queueId, edge, new TEvBlobStorage::TEvVPut(blobId, TRope(part), vdiskId, false, nullptr,
+            Runtime->Send(new IEventHandleFat(queueId, edge, new TEvBlobStorage::TEvVPut(blobId, TRope(part), vdiskId, false, nullptr,
                 TInstant::Max(), NKikimrBlobStorage::EPutHandleClass::TabletLog)), queueId.NodeId());
             auto r = WaitForEdgeActorEvent<TEvBlobStorage::TEvVPutResult>(edge);
 
@@ -610,7 +610,7 @@ struct TEnvironmentSetup {
                 if (!CommencedReplication.insert(serviceId).second) {
                     continue;
                 }
-                while (!Runtime->Send(new IEventHandle(TEvBlobStorage::EvCommenceRepl, 0, serviceId, {}, nullptr, 0), serviceId.NodeId())) {
+                while (!Runtime->Send(new IEventHandleFat(TEvBlobStorage::EvCommenceRepl, 0, serviceId, {}, nullptr, 0), serviceId.NodeId())) {
                     Sim(TDuration::Seconds(1)); // VDisk may be not created yet
                 }
                 WaitForVDiskRepl(serviceId, info->GetVDiskId(i));
@@ -629,7 +629,7 @@ struct TEnvironmentSetup {
             for (const auto& [vdiskId, queueId] : queues) {
                 const ui32 nodeId = queueId.NodeId();
                 const TActorId& edge = Runtime->AllocateEdgeActor(nodeId, __FILE__, __LINE__);
-                Runtime->Send(new IEventHandle(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeIndexQuery(
+                Runtime->Send(new IEventHandleFat(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeIndexQuery(
                     vdiskId, TInstant::Max(), NKikimrBlobStorage::EGetHandleClass::FastRead,
                     TEvBlobStorage::TEvVGet::EFlags::ShowInternals, {}, {blobId.FullID()}).release()), nodeId);
                 auto ev = WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge);
@@ -646,7 +646,7 @@ struct TEnvironmentSetup {
             Sim(TDuration::Seconds(10));
         }
         for (const auto& [vdiskId, queueId] : queues) {
-            Runtime->Send(new IEventHandle(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
+            Runtime->Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, queueId, {}, nullptr, 0), queueId.NodeId());
         }
     }
 
@@ -727,7 +727,7 @@ struct TEnvironmentSetup {
             const TActorId& edge = Runtime->AllocateEdgeActor(actorId.NodeId(), __FILE__, __LINE__);
             auto ev = std::make_unique<TEvBlobStorage::TEvVStatus>(vdiskId);
             TString request = ev->ToString();
-            Runtime->Send(new IEventHandle(actorId, edge, ev.release(), IEventHandle::FlagTrackDelivery), edge.NodeId());
+            Runtime->Send(new IEventHandleFat(actorId, edge, ev.release(), IEventHandle::FlagTrackDelivery), edge.NodeId());
             auto res = Runtime->WaitForEdgeActorEvent({edge});
             if (auto *msg = res->CastAsLocal<TEvBlobStorage::TEvVStatusResult>()) {
                 const auto& record = msg->Record;
@@ -743,7 +743,7 @@ struct TEnvironmentSetup {
             // sleep for a while
             {
                 const TActorId& edge = Runtime->AllocateEdgeActor(actorId.NodeId(), __FILE__, __LINE__);
-                Runtime->Schedule(TDuration::Minutes(1), new IEventHandle(TEvents::TSystem::Wakeup, 0, edge, {}, nullptr, 0), nullptr, edge.NodeId());
+                Runtime->Schedule(TDuration::Minutes(1), new IEventHandleFat(TEvents::TSystem::Wakeup, 0, edge, {}, nullptr, 0), nullptr, edge.NodeId());
                 WaitForEdgeActorEvent<TEvents::TEvWakeup>(edge);
             }
         }
@@ -754,7 +754,7 @@ struct TEnvironmentSetup {
         const TActorId& edge = Runtime->AllocateEdgeActor(actorId.NodeId(), __FILE__, __LINE__);
         for (;;) {
             std::unique_ptr<typename std::invoke_result_t<TFactory>::element_type> ev(factory());
-            Runtime->Send(new IEventHandle(actorId, edge, ev.release(), IEventHandle::FlagTrackDelivery), edge.NodeId());
+            Runtime->Send(new IEventHandleFat(actorId, edge, ev.release(), IEventHandle::FlagTrackDelivery), edge.NodeId());
             auto res = Runtime->WaitForEdgeActorEvent({edge});
             if (auto *msg = res->CastAsLocal<TEvents::TEvUndelivered>()) {
                 UNIT_ASSERT(checkUndelivered);
@@ -762,7 +762,7 @@ struct TEnvironmentSetup {
             } else {
                 UNIT_ASSERT_VALUES_EQUAL(res->Type, TResult::EventType);
                 Runtime->DestroyActor(edge);
-                return std::unique_ptr<TResult>(static_cast<TResult*>(res->ReleaseBase().Release()));
+                return std::unique_ptr<TResult>(IEventHandle::Release<TResult>(res));
             }
         }
     }
diff --git a/ydb/core/blobstorage/ut_blobstorage/lib/node_warden_mock_bsc.cpp b/ydb/core/blobstorage/ut_blobstorage/lib/node_warden_mock_bsc.cpp
index 16292d98e95..6ad27ff4350 100644
--- a/ydb/core/blobstorage/ut_blobstorage/lib/node_warden_mock_bsc.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/lib/node_warden_mock_bsc.cpp
@@ -158,8 +158,8 @@ void TNodeWardenMockActor::Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpd
         if (vdisk.GetDoDestroy() || vdisk.GetDoWipe()) {
             if (vdiskp) {
                 UNIT_ASSERT(vdiskp->Actor);
-                TAutoPtr<IEventHandle> ev = new IEventHandle(TEvents::TSystem::Poison, 0, {}, {}, nullptr, 0);
-                InvokeOtherActor(*vdiskp->Actor, &IActor::Receive, ev, TActivationContext::ActorContextFor(vdiskp->Actor->SelfId()));
+                TAutoPtr<IEventHandle> ev = new IEventHandleFat(TEvents::TSystem::Poison, 0, {}, {}, nullptr, 0);
+                InvokeOtherActor(*vdiskp->Actor, &IActor::Receive, ev);
                 UNIT_ASSERT(!vdiskp->Actor);
             }
             auto ev = std::make_unique<TEvBlobStorage::TEvControllerNodeReport>(SelfId().NodeId());
diff --git a/ydb/core/blobstorage/ut_blobstorage/main.cpp b/ydb/core/blobstorage/ut_blobstorage/main.cpp
index 73b302815fd..78e562b0554 100644
--- a/ydb/core/blobstorage/ut_blobstorage/main.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/main.cpp
@@ -40,7 +40,7 @@ Y_UNIT_TEST_SUITE(DonorMode) {
                 for (ui32 i = 0; i < donors.size() - 1; ++i) {
                     const TActorId& vdiskActorId = donors[i];
                     const TActorId& edge = runtime->AllocateEdgeActor(1, __FILE__, __LINE__);
-                    runtime->Send(new IEventHandle(vdiskActorId, edge, new TEvBlobStorage::TEvVStatus(),
+                    runtime->Send(new IEventHandleFat(vdiskActorId, edge, new TEvBlobStorage::TEvVStatus(),
                         IEventHandle::FlagTrackDelivery), 1);
                     auto r = runtime->WaitForEdgeActorEvent({edge});
                     runtime->DestroyActor(edge);
diff --git a/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp b/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
index b9ffea9da2c..d85ff1608bc 100644
--- a/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
@@ -100,7 +100,7 @@ Y_UNIT_TEST_SUITE(Mirror3of4) {
             auto query = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(info->GetVDiskId(i), TInstant::Max(),
                 NKikimrBlobStorage::EGetHandleClass::FastRead);
             query->AddExtremeQuery(id, 0, 0);
-            runtime->Send(new IEventHandle(queues[i], edge, query.release()), queues[i].NodeId());
+            runtime->Send(new IEventHandleFat(queues[i], edge, query.release()), queues[i].NodeId());
             auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge, false);
             Cerr << res->Get()->ToString() << Endl;
             auto& record = res->Get()->Record;
diff --git a/ydb/core/blobstorage/ut_blobstorage/osiris.cpp b/ydb/core/blobstorage/ut_blobstorage/osiris.cpp
index 627eb15f027..b39eb619941 100644
--- a/ydb/core/blobstorage/ut_blobstorage/osiris.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/osiris.cpp
@@ -44,7 +44,7 @@ bool DoTestCase(TBlobStorageGroupType::EErasureSpecies erasure, const std::set<s
         const TActorId& sender = env.Runtime->AllocateEdgeActor(queueId.NodeId());
         const TLogoBlobID blobId(id, partIdx + 1);
         TRope buffer = type.PartSize(blobId) ? parts.Parts[partIdx].OwnedString : TRope(TString());
-        env.Runtime->Send(new IEventHandle(queueId, sender, new TEvBlobStorage::TEvVPut(blobId, buffer,
+        env.Runtime->Send(new IEventHandleFat(queueId, sender, new TEvBlobStorage::TEvVPut(blobId, buffer,
             info->GetVDiskId(orderNum), false, nullptr, TInstant::Max(), NKikimrBlobStorage::TabletLog)),
             sender.NodeId());
         auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVPutResult>(sender);
@@ -83,7 +83,7 @@ bool DoTestCase(TBlobStorageGroupType::EErasureSpecies erasure, const std::set<s
         auto query = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(info->GetVDiskId(i), TInstant::Max(),
             NKikimrBlobStorage::FastRead);
         query->AddExtremeQuery(id, 0, 0);
-        env.Runtime->Send(new IEventHandle(queueId, sender, query.release()), sender.NodeId());
+        env.Runtime->Send(new IEventHandleFat(queueId, sender, query.release()), sender.NodeId());
         auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(sender);
         const auto& record = res->Get()->Record;
         Y_VERIFY(record.GetStatus() == NKikimrProto::OK);
diff --git a/ydb/core/blobstorage/ut_blobstorage/patch.cpp b/ydb/core/blobstorage/ut_blobstorage/patch.cpp
index b68c05b80ef..03ed2d7e8e1 100644
--- a/ydb/core/blobstorage/ut_blobstorage/patch.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/patch.cpp
@@ -193,7 +193,7 @@ Y_UNIT_TEST_SUITE(BlobPatching) {
                 TLogoBlobID patchedBlobId(1, 1, diffIdx + 1, 0, size, 0);
                 std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> ev = std::make_unique<TEvBlobStorage::TEvVPatchDiff>(
                         originalBlobId, patchedBlobId, info->GetVDiskId(0), 0, TInstant::Max(), 0);
-                runtime->Send(new IEventHandle(queueId, edge, ev.release()), queueId.NodeId());
+                runtime->Send(new IEventHandleFat(queueId, edge, ev.release()), queueId.NodeId());
             }
             for (ui32 diffIdx = 0; diffIdx < diffCount; ++diffIdx) {
                 auto r = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVPatchResult>(edge, false);
diff --git a/ydb/core/blobstorage/ut_blobstorage/replication.cpp b/ydb/core/blobstorage/ut_blobstorage/replication.cpp
index c6c93d7a76a..2b5eac352df 100644
--- a/ydb/core/blobstorage/ut_blobstorage/replication.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/replication.cpp
@@ -78,7 +78,7 @@ TString DoTestCase(TBlobStorageGroupType::EErasureSpecies erasure, const std::ve
         ev->AddExtremeQuery(id, 0, 0);
         const TActorId& queueId = queues[i];
         const TActorId& edge = env.Runtime->AllocateEdgeActor(queueId.NodeId());
-        env.Runtime->Send(new IEventHandle(queueId, edge, ev.release()), queueId.NodeId());
+        env.Runtime->Send(new IEventHandleFat(queueId, edge, ev.release()), queueId.NodeId());
         const bool inserted = edges.insert(edge).second;
         Y_VERIFY(inserted);
     }
@@ -148,7 +148,7 @@ TString DoTestCase(TBlobStorageGroupType::EErasureSpecies erasure, const std::ve
             auto query = std::make_unique<TEvBlobStorage::TEvVGetBarrier>(groupInfo->GetVDiskId(i), TKeyBarrier::First(),
                 TKeyBarrier::Inf(), nullptr, true);
             const TActorId& edge = env.Runtime->AllocateEdgeActor(queueId.NodeId());
-            env.Runtime->Send(new IEventHandle(queueId, edge, query.release()), edge.NodeId());
+            env.Runtime->Send(new IEventHandleFat(queueId, edge, query.release()), edge.NodeId());
             const bool inserted = edges.insert(edge).second;
             Y_VERIFY(inserted);
         }
@@ -208,7 +208,7 @@ TString DoTestCase(TBlobStorageGroupType::EErasureSpecies erasure, const std::ve
 
     filterFunction = [&](ui32 nodeId, std::unique_ptr<IEventHandle>& ev) {
         if (ev->Type == TEvBlobStorage::EvVGet && states[ev->Recipient.NodeId() - 1] == EState::OFFLINE) {
-            env.Runtime->Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected).Release(), nodeId);
+            env.Runtime->Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected).Release(), nodeId);
             return false;
         }
         return true;
diff --git a/ydb/core/blobstorage/ut_blobstorage/scrub.cpp b/ydb/core/blobstorage/ut_blobstorage/scrub.cpp
index 4d0b27d4506..bb26b7f743f 100644
--- a/ydb/core/blobstorage/ut_blobstorage/scrub.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/scrub.cpp
@@ -37,7 +37,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
 
                 bool done = false;
                 for (;;) {
-                    env.Runtime->Send(new IEventHandle(vdiskActorId, sender, new TEvBlobStorage::TEvCaptureVDiskLayout),
+                    env.Runtime->Send(new IEventHandleFat(vdiskActorId, sender, new TEvBlobStorage::TEvCaptureVDiskLayout),
                         sender.NodeId());
                     auto res = env.WaitForEdgeActorEvent<TLayout>(sender, false);
                     layout.reset(res->Release().Release());
@@ -82,7 +82,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
             const TActorId& sender = env.Runtime->AllocateEdgeActor(queueId.NodeId());
             auto ev = TEvBlobStorage::TEvVGet::CreateRangeIndexQuery(vdiskId, TInstant::Max(),
                 NKikimrBlobStorage::EGetHandleClass::FastRead, {}, {}, fromId, toId, 1000);
-            env.Runtime->Send(new IEventHandle(queueId, sender, ev.release()), sender.NodeId());
+            env.Runtime->Send(new IEventHandleFat(queueId, sender, ev.release()), sender.NodeId());
             auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(sender);
             auto& r = res->Get()->Record;
             UNIT_ASSERT_VALUES_EQUAL(r.GetStatus(), NKikimrProto::OK);
@@ -93,7 +93,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
                 auto ev = TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(vdiskId, TInstant::Max(),
                     NKikimrBlobStorage::EGetHandleClass::FastRead, {}, {}, {id});
                 const TActorId& sender = env.Runtime->AllocateEdgeActor(queueId.NodeId());
-                env.Runtime->Send(new IEventHandle(queueId, sender, ev.release()), sender.NodeId());
+                env.Runtime->Send(new IEventHandleFat(queueId, sender, ev.release()), sender.NodeId());
                 auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(sender);
                 auto& r = res->Get()->Record;
                 UNIT_ASSERT_VALUES_EQUAL(r.GetStatus(), NKikimrProto::OK);
@@ -126,7 +126,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
             const ui32 partSize = type.PartSize(key);
             const ui32 size = partSize + BlobProtobufHeaderMaxSize;
             if (size + total > 60000000) {
-                env.Runtime->Send(new IEventHandle(queueId, edge, ev.release()), edge.NodeId());
+                env.Runtime->Send(new IEventHandleFat(queueId, edge, ev.release()), edge.NodeId());
                 total = 0;
                 ++numMsgs;
             }
@@ -139,7 +139,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
             ++numBlobs;
         }
         if (ev) {
-            env.Runtime->Send(new IEventHandle(queueId, edge, ev.release()), edge.NodeId());
+            env.Runtime->Send(new IEventHandleFat(queueId, edge, ev.release()), edge.NodeId());
             ++numMsgs;
         }
         while (numMsgs--) {
@@ -155,7 +155,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
         }
         UNIT_ASSERT(!numBlobs);
 
-        env.Runtime->Send(new IEventHandle(TEvents::TSystem::Poison, 0, queueId, edge, nullptr, 0), 1);
+        env.Runtime->Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, queueId, edge, nullptr, 0), 1);
         env.Runtime->DestroyActor(edge);
     }
 
@@ -341,7 +341,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
                 const ui32 nodeId = vdiskActorId.NodeId();
                 const TActorId& edge = runtime->AllocateEdgeActor(nodeId);
                 const ui64 cookie = RandomNumber<ui64>();
-                runtime->Send(new IEventHandle(TEvBlobStorage::EvScrubAwait, 0, vdiskActorId, edge, nullptr, cookie), nodeId);
+                runtime->Send(new IEventHandleFat(TEvBlobStorage::EvScrubAwait, 0, vdiskActorId, edge, nullptr, cookie), nodeId);
                 auto ev = env.WaitForEdgeActorEvent<TEvScrubNotify>(edge);
                 UNIT_ASSERT_VALUES_EQUAL(ev->Cookie, cookie);
                 passedCheckpoints |= ev->Get()->Checkpoints;
@@ -354,7 +354,7 @@ Y_UNIT_TEST_SUITE(BlobScrubbing) {
             for (ui32 i = 1; i < info->GetTotalVDisksNum(); ++i) {
                 const TActorId& actorId = info->GetActorId(i);
                 Cerr << "*** terminating peer disk# " << actorId.ToString() << Endl;
-                runtime->Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0), actorId.NodeId());
+                runtime->Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0), actorId.NodeId());
             }
 
             Cerr << "*** blobIdsToValidate.size# " << blobIdsToValidate.size() << Endl;
diff --git a/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp b/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
index c487f20214f..7065e8c8428 100644
--- a/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
@@ -36,7 +36,7 @@ Y_UNIT_TEST_SUITE(SnapshotTesting) {
                 const TLogoBlobID id(tabletId, generation, step, channel, len, 0, 1);
                 auto ev = std::make_unique<TEvBlobStorage::TEvVPut>(id, TRope(data), vdiskId, false, nullptr, TInstant::Max(),
                     NKikimrBlobStorage::EPutHandleClass::TabletLog);
-                runtime->Send(new IEventHandle(queue, edge, ev.release()), queue.NodeId());
+                runtime->Send(new IEventHandleFat(queue, edge, ev.release()), queue.NodeId());
                 if (putToBlobs) {
                     blobs.emplace(id, std::move(data));
                 }
@@ -57,7 +57,7 @@ Y_UNIT_TEST_SUITE(SnapshotTesting) {
             Cerr << "doCompact" << Endl;
             const TInstant begin = runtime->GetClock();
 
-            auto ev = std::make_unique<IEventHandle>(vdiskActorId, edge, TEvCompactVDisk::Create(EHullDbType::LogoBlobs));
+            auto ev = std::make_unique<IEventHandleFat>(vdiskActorId, edge, TEvCompactVDisk::Create(EHullDbType::LogoBlobs));
             ev->Rewrite(TEvBlobStorage::EvForwardToSkeleton, vdiskActorId);
             runtime->Send(ev.release(), edge.NodeId());
             env.WaitForEdgeActorEvent<TEvCompactVDiskResult>(edge, false);
@@ -97,7 +97,7 @@ Y_UNIT_TEST_SUITE(SnapshotTesting) {
                 if (snapshotId) {
                     ev->Record.SetSnapshotId(*snapshotId);
                 }
-                runtime->Send(new IEventHandle(queue, edge, ev.release()), queue.NodeId());
+                runtime->Send(new IEventHandleFat(queue, edge, ev.release()), queue.NodeId());
                 { // check result
                     auto ev = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge, false);
                     const auto& record = ev->Get()->Record;
@@ -133,7 +133,7 @@ Y_UNIT_TEST_SUITE(SnapshotTesting) {
 
             auto ev = std::make_unique<TEvBlobStorage::TEvVCollectGarbage>(tabletId, generation, step, channel, true,
                 generation, step, false, nullptr, nullptr, vdiskId, TInstant::Max());
-            runtime->Send(new IEventHandle(queue, edge, ev.release()), queue.NodeId());
+            runtime->Send(new IEventHandleFat(queue, edge, ev.release()), queue.NodeId());
             { // check result
                 auto ev = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVCollectGarbageResult>(edge, false);
                 const auto& record = ev->Get()->Record;
diff --git a/ydb/core/blobstorage/ut_blobstorage/sync.cpp b/ydb/core/blobstorage/ut_blobstorage/sync.cpp
index d092eac9b9c..3033a98581c 100644
--- a/ydb/core/blobstorage/ut_blobstorage/sync.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/sync.cpp
@@ -43,7 +43,7 @@ Y_UNIT_TEST_SUITE(BlobStorageSync) {
                 const TVDiskID vdiskId = info->GetVDiskId(i);
                 const TActorId queueId = queues.at(vdiskId);
                 const TActorId edge = runtime->AllocateEdgeActor(queueId.NodeId(), __FILE__, __LINE__);
-                runtime->Send(new IEventHandle(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(
+                runtime->Send(new IEventHandleFat(queueId, edge, TEvBlobStorage::TEvVGet::CreateExtremeDataQuery(
                     vdiskId, TInstant::Max(), NKikimrBlobStorage::EGetHandleClass::FastRead,
                     TEvBlobStorage::TEvVGet::EFlags::ShowInternals, {}, {{id}}).release()), queueId.NodeId());
                 auto res = env.WaitForEdgeActorEvent<TEvBlobStorage::TEvVGetResult>(edge);
@@ -95,7 +95,7 @@ Y_UNIT_TEST_SUITE(BlobStorageSync) {
             const TActorId actorId = info->GetActorId(i);
             if (actorId.NodeId() != suspendedNodeId) {
                 const auto& sender = env.Runtime->AllocateEdgeActor(actorId.NodeId());
-                auto ev = std::make_unique<IEventHandle>(actorId, sender, TEvCompactVDisk::Create(EHullDbType::LogoBlobs));
+                auto ev = std::make_unique<IEventHandleFat>(actorId, sender, TEvCompactVDisk::Create(EHullDbType::LogoBlobs));
                 ev->Rewrite(TEvBlobStorage::EvForwardToSkeleton, actorId);
                 runtime->Send(ev.release(), sender.NodeId());
                 auto res = env.WaitForEdgeActorEvent<TEvCompactVDiskResult>(sender);
diff --git a/ydb/core/blobstorage/ut_group/main.cpp b/ydb/core/blobstorage/ut_group/main.cpp
index d703975dcf1..a9d91b9e7cd 100644
--- a/ydb/core/blobstorage/ut_group/main.cpp
+++ b/ydb/core/blobstorage/ut_group/main.cpp
@@ -114,7 +114,7 @@ public:
     void ForwardToProxy(TAutoPtr<IEventHandle> ev) {
         const TGroupID groupId(GroupIDFromBlobStorageProxyID(ev->GetForwardOnNondeliveryRecipient()));
         const ui32 id = groupId.GetRaw();
-        TActivationContext::Send(ev->Forward(MakeBlobStorageProxyID(id)));
+        Forward(ev, MakeBlobStorageProxyID(id));
     }
 
     STRICT_STFUNC(StateFunc,
@@ -257,14 +257,14 @@ public:
     void RestartDisk(TTestActorSystem& runtime, TDiskRecord& disk) {
         LOG_NOTICE_S(runtime, NActorsServices::TEST, "Restarting " << disk.VDiskId << " over NodeId# " << disk.NodeId
             << " PDiskId# " << disk.PDiskId);
-        runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, disk.VDiskActorId, TActorId(), nullptr, 0), disk.NodeId);
+        runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, disk.VDiskActorId, TActorId(), nullptr, 0), disk.NodeId);
         StartVDisk(runtime, disk);
     }
 
     void FormatDisk(TTestActorSystem& runtime, TDiskRecord& disk) {
         LOG_NOTICE_S(runtime, NActorsServices::TEST, "Formatting " << disk.VDiskId << " over NodeId# " << disk.NodeId
             << " PDiskId# " << disk.PDiskId << " DiskStatus# " << GetDiskStatusMap());
-        runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, disk.VDiskActorId, TActorId(), nullptr, 0), disk.NodeId);
+        runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, disk.VDiskActorId, TActorId(), nullptr, 0), disk.NodeId);
         Slay(runtime, disk);
         StartVDisk(runtime, disk);
     }
@@ -295,7 +295,7 @@ public:
         Slay(runtime, disk);
 
         // terminate running VDisk directly
-        runtime.Send(new IEventHandle(TEvents::TSystem::Poison, 0, disk.VDiskActorId, TActorId(), nullptr, 0), disk.NodeId);
+        runtime.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, disk.VDiskActorId, TActorId(), nullptr, 0), disk.NodeId);
 
         // fill in new VDisk params
         const ui32 vdiskSlotId = ++NextVDiskSlotId[std::make_tuple(nodeId, pdiskId)];
@@ -322,13 +322,13 @@ public:
         for (TDiskRecord& disk : Disks) {
             if (disk.VDiskId.GroupGeneration != Info->GroupGeneration) {
                 disk.VDiskId = TVDiskID(Info->GroupID, Info->GroupGeneration, disk.VDiskId);
-                runtime.Send(new IEventHandle(disk.VDiskActorId, {}, new TEvVGenerationChange(disk.VDiskId, Info)),
+                runtime.Send(new IEventHandleFat(disk.VDiskActorId, {}, new TEvVGenerationChange(disk.VDiskId, Info)),
                     disk.VDiskActorId.NodeId());
             }
         }
 
         // update group info for proxy
-        runtime.Send(new IEventHandle(MakeBlobStorageProxyID(Info->GroupID), TActorId(),
+        runtime.Send(new IEventHandleFat(MakeBlobStorageProxyID(Info->GroupID), TActorId(),
             new TEvBlobStorage::TEvConfigureProxy(Info, StoragePoolCounters)), 1);
     }
 
@@ -336,7 +336,7 @@ public:
         LOG_INFO_S(runtime, NActorsServices::TEST, "Slaying VDiskId# " << disk.VDiskId);
         const TActorId& edge = runtime.AllocateEdgeActor(disk.NodeId);
         auto slay = std::make_unique<NPDisk::TEvSlay>(disk.VDiskId, ++Round, disk.PDiskId, disk.VDiskSlotId);
-        runtime.Send(new IEventHandle(disk.PDiskActorId, edge, slay.release()), disk.NodeId);
+        runtime.Send(new IEventHandleFat(disk.PDiskActorId, edge, slay.release()), disk.NodeId);
         auto res = runtime.WaitForEdgeActorEvent({edge});
         if (const auto *ev = res->CastAsLocal<NPDisk::TEvSlayResult>()) {
             Y_VERIFY_S(ev->Status == NKikimrProto::OK || ev->Status == NKikimrProto::ALREADY, "TEvSlayResult# " << ev->ToString());
@@ -461,12 +461,12 @@ public:
     }
 
     template<typename TEvent, typename... TArgs>
-    TAutoPtr<TEventHandle<TResultFor<TEvent>>> Query(TArgs&&... args) {
+    TAutoPtr<TEventHandleFat<TResultFor<TEvent>>> Query(TArgs&&... args) {
         auto q = std::make_unique<TEvent>(std::forward<TArgs>(args)...);
         LOG_DEBUG_S(GetActorContext(), NActorsServices::TEST, Prefix << " sending " << TypeName<TEvent>() << "# "
             << q->Print(false));
         GetActorSystem()->Schedule(TDuration::MicroSeconds(TAppData::RandomProvider->Uniform(10, 100)),
-            new IEventHandle(ProxyId, SelfActorId, q.release()));
+            new IEventHandleFat(ProxyId, SelfActorId, q.release()));
         ++*Counter;
         auto ev = WaitForSpecificEvent<TResultFor<TEvent>>();
         LOG_DEBUG_S(GetActorContext(), NActorsServices::TEST, Prefix << " received "
diff --git a/ydb/core/blobstorage/ut_testshard/env.h b/ydb/core/blobstorage/ut_testshard/env.h
index 6d251269b21..cd266b55368 100644
--- a/ydb/core/blobstorage/ut_testshard/env.h
+++ b/ydb/core/blobstorage/ut_testshard/env.h
@@ -143,7 +143,7 @@ struct TEnvironmentSetup {
         });
 
         auto res = Runtime->WaitForEdgeActorEvent<TEvBlobStorage::TEvControllerConfigResponse>(edge)->Get()->Record.GetResponse();
-        Runtime->Send(new IEventHandle(clientId, edge, new NKikimr::TEvTabletPipe::TEvShutdown()), edge.NodeId());
+        Runtime->Send(new IEventHandleFat(clientId, edge, new NKikimr::TEvTabletPipe::TEvShutdown()), edge.NodeId());
         return res;
     }
 
diff --git a/ydb/core/blobstorage/ut_vdisk/lib/vdisk_mock.cpp b/ydb/core/blobstorage/ut_vdisk/lib/vdisk_mock.cpp
index 9dcec09c1bc..47203149bf5 100644
--- a/ydb/core/blobstorage/ut_vdisk/lib/vdisk_mock.cpp
+++ b/ydb/core/blobstorage/ut_vdisk/lib/vdisk_mock.cpp
@@ -32,7 +32,7 @@ public:
     template<typename T>
     static void FinalizeAndSend(std::unique_ptr<T> ptr, const TActorContext& ctx, const TActorId& recipient) {
         T* const p = ptr.get();
-        p->FinalizeAndSend(ctx, std::make_unique<IEventHandle>(recipient, ctx.SelfID, ptr.release()));
+        p->FinalizeAndSend(ctx, std::make_unique<IEventHandleFat>(recipient, ctx.SelfID, ptr.release()));
     }
 
     void Bootstrap(const TActorContext& ctx) {
diff --git a/ydb/core/blobstorage/ut_vdisk2/env.h b/ydb/core/blobstorage/ut_vdisk2/env.h
index c49be6067b0..1b92c0ae1ab 100644
--- a/ydb/core/blobstorage/ut_vdisk2/env.h
+++ b/ydb/core/blobstorage/ut_vdisk2/env.h
@@ -76,7 +76,7 @@ namespace NKikimr {
         decltype(std::declval<TEvVResult>().Record) ExecuteQuery(std::unique_ptr<IEventBase> query,
                 NKikimrBlobStorage::EVDiskQueueId queueId) {
             const TActorId& edge = Runtime->AllocateEdgeActor(NodeId);
-            Runtime->Send(new IEventHandle(QueueIds.at(queueId), edge, query.release()), NodeId);
+            Runtime->Send(new IEventHandleFat(QueueIds.at(queueId), edge, query.release()), NodeId);
             auto ev = Runtime->WaitForEdgeActorEvent({edge});
             Runtime->DestroyActor(edge);
             auto *msg = ev->CastAsLocal<TEvVResult>();
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_response.cpp b/ydb/core/blobstorage/vdisk/common/vdisk_response.cpp
index df61982aa02..97aa7df36ec 100644
--- a/ydb/core/blobstorage/vdisk/common/vdisk_response.cpp
+++ b/ydb/core/blobstorage/vdisk/common/vdisk_response.cpp
@@ -34,7 +34,7 @@ void SendVDiskResponse(const TActorContext &ctx, const TActorId &recipient, IEve
             break;
     }
 
-    auto event = std::make_unique<IEventHandle>(recipient, ctx.SelfID, ev, IEventHandle::MakeFlags(channel, 0), cookie);
+    auto event = std::make_unique<IEventHandleFat>(recipient, ctx.SelfID, ev, IEventHandle::MakeFlags(channel, 0), cookie);
     if (TEvVResultBase *base = dynamic_cast<TEvVResultBase *>(ev)) {
         base->FinalizeAndSend(ctx, std::move(event));
     } else {
diff --git a/ydb/core/blobstorage/vdisk/defrag/defrag_actor.cpp b/ydb/core/blobstorage/vdisk/defrag/defrag_actor.cpp
index 86443524a2e..f460dee3960 100644
--- a/ydb/core/blobstorage/vdisk/defrag/defrag_actor.cpp
+++ b/ydb/core/blobstorage/vdisk/defrag/defrag_actor.cpp
@@ -159,7 +159,7 @@ namespace NKikimr {
             Y_VERIFY(ev->Sender == PlannerId);
             PlannerId = {};
             if (ev->Get()->ChunksToDefrag) {
-                ctx.Send(new IEventHandle(DefragActorId, SelfId(), ev->ReleaseBase().Release()));
+                ctx.Send(new IEventHandleFat(DefragActorId, SelfId(), ev->ReleaseBase().Release()));
             } else {
                 ctx.Schedule(GeneratePause(), new TEvents::TEvWakeup);
             }
@@ -171,7 +171,7 @@ namespace NKikimr {
 
         void Die(const TActorContext& ctx) override {
             if (PlannerId) {
-                ctx.Send(new IEventHandle(TEvents::TSystem::Poison, 0, PlannerId, {}, nullptr, 0));
+                ctx.Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, PlannerId, {}, nullptr, 0));
             }
             TActorBootstrapped::Die(ctx);
         }
diff --git a/ydb/core/blobstorage/vdisk/defrag/defrag_quantum.cpp b/ydb/core/blobstorage/vdisk/defrag/defrag_quantum.cpp
index 4f907a2fb09..461481c2132 100644
--- a/ydb/core/blobstorage/vdisk/defrag/defrag_quantum.cpp
+++ b/ydb/core/blobstorage/vdisk/defrag/defrag_quantum.cpp
@@ -71,7 +71,7 @@ namespace NKikimr {
                 try {
                     ev = WaitForSpecificEvent<TEvDefragRewritten>();
                 } catch (const TPoisonPillException&) {
-                    Send(new IEventHandle(TEvents::TSystem::Poison, 0, rewriterActorId, {}, nullptr, 0));
+                    Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, rewriterActorId, {}, nullptr, 0));
                     throw;
                 }
                 stat.RewrittenRecs = ev->Get()->RewrittenRecs;
@@ -92,7 +92,7 @@ namespace NKikimr {
         }
 
         void Yield() {
-            Send(new IEventHandle(EvResume, 0, SelfActorId, {}, nullptr, 0));
+            Send(new IEventHandleFat(EvResume, 0, SelfActorId, {}, nullptr, 0));
             WaitForSpecificEvent([](IEventHandle& ev) { return ev.Type == EvResume; });
         }
 
diff --git a/ydb/core/blobstorage/vdisk/hullop/hullcompdelete/blobstorage_hullcompdelete.h b/ydb/core/blobstorage/vdisk/hullop/hullcompdelete/blobstorage_hullcompdelete.h
index c3a7715cc37..44dbd19d10b 100644
--- a/ydb/core/blobstorage/vdisk/hullop/hullcompdelete/blobstorage_hullcompdelete.h
+++ b/ydb/core/blobstorage/vdisk/hullop/hullcompdelete/blobstorage_hullcompdelete.h
@@ -217,7 +217,7 @@ namespace NKikimr {
                     ctx.Send(hugeKeeperId, new TEvHullFreeHugeSlots(std::move(item.RemovedHugeBlobs),
                         item.RecordLsn, item.Signature));
                     if (item.ChunksToForget) {
-                        TActivationContext::Send(new IEventHandle(pdiskCtx->PDiskId, skeletonId, new NPDisk::TEvChunkForget(
+                        TActivationContext::Send(new IEventHandleFat(pdiskCtx->PDiskId, skeletonId, new NPDisk::TEvChunkForget(
                             pdiskCtx->Dsk->Owner, pdiskCtx->Dsk->OwnerRound, std::move(item.ChunksToForget))));
                     }
                     ReleaseQueue.pop_front();
@@ -242,7 +242,7 @@ namespace NKikimr {
 
         // implemented in blobstorage_hull.h
         ~TDelayedCompactionDeleterNotifier() {
-            ActorSystem->Send(new IEventHandle(Info->GetActorId(), TActorId(), new TEvHullReleaseSnapshot(Cookie)));
+            ActorSystem->Send(new IEventHandleFat(Info->GetActorId(), TActorId(), new TEvHullReleaseSnapshot(Cookie)));
         }
     };
 
diff --git a/ydb/core/blobstorage/vdisk/localrecovery/localrecovery_public.cpp b/ydb/core/blobstorage/vdisk/localrecovery/localrecovery_public.cpp
index 468407e7096..5dc6dfbe9d8 100644
--- a/ydb/core/blobstorage/vdisk/localrecovery/localrecovery_public.cpp
+++ b/ydb/core/blobstorage/vdisk/localrecovery/localrecovery_public.cpp
@@ -566,7 +566,7 @@ namespace NKikimr {
         void SendYardInit(const TActorContext &ctx, TDuration yardInitDelay) {
             auto ev = std::make_unique<NPDisk::TEvYardInit>(Config->BaseInfo.InitOwnerRound, SelfVDiskId,
                 Config->BaseInfo.PDiskGuid, SkeletonId, SkeletonFrontId, Config->BaseInfo.VDiskSlotId);
-            auto handle = std::make_unique<IEventHandle>(Config->BaseInfo.PDiskActorID, SelfId(), ev.release(),
+            auto handle = std::make_unique<IEventHandleFat>(Config->BaseInfo.PDiskActorID, SelfId(), ev.release(),
                 IEventHandle::FlagTrackDelivery);
             if (yardInitDelay != TDuration::Zero()) {
                 TActivationContext::Schedule(yardInitDelay, handle.release());
diff --git a/ydb/core/blobstorage/vdisk/query/assimilation.cpp b/ydb/core/blobstorage/vdisk/query/assimilation.cpp
index 376cf139e83..c8056f353b9 100644
--- a/ydb/core/blobstorage/vdisk/query/assimilation.cpp
+++ b/ydb/core/blobstorage/vdisk/query/assimilation.cpp
@@ -208,7 +208,7 @@ namespace NKikimr {
 
                 Process(iter);
                 if (iter.NeedConstraintCheck() && TDuration::Seconds(timer.Passed()) >= MaxQuantumTime) {
-                    TActivationContext::Send(new IEventHandle(EvResume, 0, SelfId(), {}, nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(EvResume, 0, SelfId(), {}, nullptr, 0));
                     return false; // has to restart
                 }
             }
@@ -226,7 +226,7 @@ namespace NKikimr {
         }
 
         void PassAway() override {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::ActorDied, 0, ParentId, SelfId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::ActorDied, 0, ParentId, SelfId(), nullptr, 0));
             TActorBootstrapped::PassAway();
         }
 
diff --git a/ydb/core/blobstorage/vdisk/query/query_readactor.cpp b/ydb/core/blobstorage/vdisk/query/query_readactor.cpp
index 664e57d90bb..eb0f30d6ed6 100644
--- a/ydb/core/blobstorage/vdisk/query/query_readactor.cpp
+++ b/ydb/core/blobstorage/vdisk/query/query_readactor.cpp
@@ -47,7 +47,7 @@ namespace NKikimr {
                     VDISKP(Ctx->VCtx->VDiskLogPrefix, "GLUEREAD(%p): %s", this, msg->ToString().data()));
 
                 // send request
-                TReplQuoter::QuoteMessage(quoter, std::make_unique<IEventHandle>(Ctx->PDiskCtx->PDiskId, SelfId(),
+                TReplQuoter::QuoteMessage(quoter, std::make_unique<IEventHandleFat>(Ctx->PDiskCtx->PDiskId, SelfId(),
                     msg.release(), 0, 0, nullptr, Span.GetTraceId()), it->Part.Size);
 
                 Counter++;
diff --git a/ydb/core/blobstorage/vdisk/repl/blobstorage_hullrepljob.cpp b/ydb/core/blobstorage/vdisk/repl/blobstorage_hullrepljob.cpp
index 3922576af36..62441b9338a 100644
--- a/ydb/core/blobstorage/vdisk/repl/blobstorage_hullrepljob.cpp
+++ b/ydb/core/blobstorage/vdisk/repl/blobstorage_hullrepljob.cpp
@@ -469,7 +469,7 @@ namespace NKikimr {
                             const ui64 bytes = write->PartsPtr ? write->PartsPtr->ByteSize() : 0;
                             ReplInfo->SstBytesWritten += bytes;
                             // and check if we have to postpone it
-                            TReplQuoter::QuoteMessage(ReplCtx->VCtx->ReplPDiskWriteQuoter, std::make_unique<IEventHandle>(
+                            TReplQuoter::QuoteMessage(ReplCtx->VCtx->ReplPDiskWriteQuoter, std::make_unique<IEventHandleFat>(
                                 ReplCtx->PDiskCtx->PDiskId, SelfId(), msg.release()), bytes);
                         } else {
                             Send(ReplCtx->PDiskCtx->PDiskId, msg.release());
@@ -731,7 +731,7 @@ namespace NKikimr {
                     ReplCtx->MonGroup.ReplHugeBlobBytesRecovered() += front.Data.GetSize();
 
                     const ui64 bytes = front.Data.GetSize();
-                    TReplQuoter::QuoteMessage(ReplCtx->VCtx->ReplPDiskWriteQuoter, std::make_unique<IEventHandle>(
+                    TReplQuoter::QuoteMessage(ReplCtx->VCtx->ReplPDiskWriteQuoter, std::make_unique<IEventHandleFat>(
                         ReplCtx->SkeletonId, SelfId(), new TEvRecoveredHugeBlob(front.Id, std::move(front.Data))),
                         bytes);
 
diff --git a/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp b/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp
index cab2fe9bd82..781b9e6d828 100644
--- a/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp
+++ b/ydb/core/blobstorage/vdisk/repl/blobstorage_repl.cpp
@@ -366,7 +366,7 @@ namespace NKikimr {
             }
 
             History.Push(info);
-            
+
 #ifndef NDEBUG
             // validate history -- work units must decrease consistently with work units processed
             TEvReplFinished::TInfoPtr prev = nullptr;
@@ -419,7 +419,7 @@ namespace NKikimr {
                     ReplCtx->MonGroup.ReplWorkUnitsDone() = 0;
                     ReplCtx->MonGroup.ReplItemsRemaining() = 0;
                     ReplCtx->MonGroup.ReplItemsDone() = 0;
-                    TActivationContext::Send(new IEventHandle(TEvBlobStorage::EvReplDone, 0, ReplCtx->SkeletonId,
+                    TActivationContext::Send(new IEventHandleFat(TEvBlobStorage::EvReplDone, 0, ReplCtx->SkeletonId,
                         SelfId(), nullptr, 0));
                 }
             } else {
diff --git a/ydb/core/blobstorage/vdisk/scrub/blob_recovery_impl.h b/ydb/core/blobstorage/vdisk/scrub/blob_recovery_impl.h
index 0e9022168f2..ccb6da3f314 100644
--- a/ydb/core/blobstorage/vdisk/scrub/blob_recovery_impl.h
+++ b/ydb/core/blobstorage/vdisk/scrub/blob_recovery_impl.h
@@ -69,7 +69,7 @@ namespace NKikimr {
             std::unique_ptr<TEvRecoverBlobResult> Result; // pending response message
             ui32 NumUnrespondedBlobs = 0; // number of blobs with UNKNOWN status
 
-            TInFlightContext(ui64 requestId, TEventHandle<TEvRecoverBlob>& ev)
+            TInFlightContext(ui64 requestId, TEventHandleFat<TEvRecoverBlob>& ev)
                 : RequestId(requestId)
                 , Sender(ev.Sender)
                 , Cookie(ev.Cookie)
diff --git a/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp b/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp
index 6e4c2b66758..b036de8b058 100644
--- a/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp
+++ b/ydb/core/blobstorage/vdisk/scrub/blob_recovery_queue.cpp
@@ -19,7 +19,7 @@ namespace NKikimr {
 
     void TBlobRecoveryActor::StopQueues() {
         for (const auto& [vdiskId, queue] : Queues) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, queue.QueueActorId, {}, nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, queue.QueueActorId, {}, nullptr, 0));
         }
     }
 
diff --git a/ydb/core/blobstorage/vdisk/scrub/scrub_actor.cpp b/ydb/core/blobstorage/vdisk/scrub/scrub_actor.cpp
index ee81a7d832b..ce40aad3cd5 100644
--- a/ydb/core/blobstorage/vdisk/scrub/scrub_actor.cpp
+++ b/ydb/core/blobstorage/vdisk/scrub/scrub_actor.cpp
@@ -49,7 +49,8 @@ namespace NKikimr {
     }
 
     void TScrubCoroImpl::ForwardToBlobRecoveryActor(TAutoPtr<IEventHandle> ev) {
-        Send(ev->Forward(BlobRecoveryActorId));
+        IEventHandle::Forward(ev, BlobRecoveryActorId);
+        Send(ev);
     }
 
     void TScrubCoroImpl::Run() {
@@ -85,7 +86,7 @@ namespace NKikimr {
         } catch (const TPoisonPillException&) { // poison pill from the skeleton
             STLOGX(GetActorContext(), PRI_DEBUG, BS_VDISK_SCRUB, VDS25, VDISKP(LogPrefix, "catched TPoisonPillException"));
         }
-        Send(new IEventHandle(TEvents::TSystem::Poison, 0, std::exchange(BlobRecoveryActorId, {}), {}, nullptr, 0));
+        Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, std::exchange(BlobRecoveryActorId, {}), {}, nullptr, 0));
     }
 
     void TScrubCoroImpl::RequestState() {
diff --git a/ydb/core/blobstorage/vdisk/scrub/scrub_actor_impl.h b/ydb/core/blobstorage/vdisk/scrub/scrub_actor_impl.h
index 3097197cc22..007cd7e78bb 100644
--- a/ydb/core/blobstorage/vdisk/scrub/scrub_actor_impl.h
+++ b/ydb/core/blobstorage/vdisk/scrub/scrub_actor_impl.h
@@ -80,8 +80,8 @@ namespace NKikimr {
         void UpdateReadableParts(const TLogoBlobID& fullId, NMatrix::TVectorType readable);
 
         ui64 GenerateRestoreCorruptedBlobQuery();
-        void Handle(TAutoPtr<TEventHandle<TEvRestoreCorruptedBlobResult>> ev);
-        void Handle(TAutoPtr<TEventHandle<TEvNonrestoredCorruptedBlobNotify>> ev);
+        void Handle(TAutoPtr<TEventHandleFat<TEvRestoreCorruptedBlobResult>> ev);
+        void Handle(TAutoPtr<TEventHandleFat<TEvNonrestoredCorruptedBlobNotify>> ev);
         void HandleGenerateRestoreCorruptedBlobQuery();
 
     public:
diff --git a/ydb/core/blobstorage/vdisk/scrub/scrub_actor_unreadable.cpp b/ydb/core/blobstorage/vdisk/scrub/scrub_actor_unreadable.cpp
index 7d717019269..56666e29e93 100644
--- a/ydb/core/blobstorage/vdisk/scrub/scrub_actor_unreadable.cpp
+++ b/ydb/core/blobstorage/vdisk/scrub/scrub_actor_unreadable.cpp
@@ -135,7 +135,7 @@ namespace NKikimr {
                 }
             }
             if (when != TInstant::Max()) {
-                GetActorSystem()->Schedule(when, new IEventHandle(EvGenerateRestoreCorruptedBlobQuery, 0, SelfActorId,
+                GetActorSystem()->Schedule(when, new IEventHandleFat(EvGenerateRestoreCorruptedBlobQuery, 0, SelfActorId,
                     {}, nullptr, 0));
                 GenerateRestoreCorruptedBlobQueryScheduled = true;
             }
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp
index b97f27901dd..801389cd7eb 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp
@@ -115,7 +115,7 @@ namespace NKikimr {
         }
 
         template<typename TEvent>
-        bool CheckIfWriteAllowed(TAutoPtr<TEventHandle<TEvent>>& ev, const TActorContext& ctx) {
+        bool CheckIfWriteAllowed(TAutoPtr<TEventHandleFat<TEvent>>& ev, const TActorContext& ctx) {
             if (!SelfVDiskId.SameDisk(ev->Get()->Record.GetVDiskID())) {
                 ReplyError(NKikimrProto::RACE, "group generation mismatch", ev, ctx, TAppData::TimeProvider->Now());
             } else if (Config->BaseInfo.DonorMode) {
@@ -1969,7 +1969,7 @@ namespace NKikimr {
                     Db->ReplID.Set(ctx.Register(CreateReplActor(replCtx)));
                     ActiveActors.Insert(Db->ReplID); // keep forever
                     if (CommenceRepl) {
-                        TActivationContext::Send(new IEventHandle(TEvBlobStorage::EvCommenceRepl, 0, Db->ReplID, SelfId(),
+                        TActivationContext::Send(new IEventHandleFat(TEvBlobStorage::EvCommenceRepl, 0, Db->ReplID, SelfId(),
                             nullptr, 0));
                     }
                 }
@@ -2330,16 +2330,16 @@ namespace NKikimr {
         void HandleCommenceRepl(const TActorContext& /*ctx*/) {
             CommenceRepl = true;
             if (Db->ReplID) {
-                TActivationContext::Send(new IEventHandle(TEvBlobStorage::EvCommenceRepl, 0, Db->ReplID, SelfId(), nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvBlobStorage::EvCommenceRepl, 0, Db->ReplID, SelfId(), nullptr, 0));
             }
         }
 
         void ForwardToScrubActor(STFUNC_SIG) {
-            ctx.Send(ev->Forward(ScrubId));
+            ctx.Forward(ev, ScrubId);
         }
 
         void ForwardToDefragActor(STFUNC_SIG) {
-            ctx.Send(ev->Forward(DefragId));
+            ctx.Forward(ev, DefragId);
         }
 
         void Handle(TEvReportScrubStatus::TPtr ev, const TActorContext& ctx) {
@@ -2362,7 +2362,7 @@ namespace NKikimr {
         }
 
         void ForwardToLogoBlobsLevelIndexActor(STFUNC_SIG) {
-            ctx.Send(ev->Forward(Hull->GetHullDs()->LogoBlobs->LIActor));
+            ctx.Forward(ev, Hull->GetHullDs()->LogoBlobs->LIActor);
         }
 
         void Handle(NPDisk::TEvChunkForgetResult::TPtr ev) {
@@ -2416,7 +2416,7 @@ namespace NKikimr {
             if (!SnapshotExpirationMap.empty()) {
                 const TMonotonic when = SnapshotExpirationMap.begin()->first;
                 if (SnapshotExpirationCheckSchedule.empty() || when < SnapshotExpirationCheckSchedule.front()) {
-                    TActivationContext::Schedule(when, new IEventHandle(TEvPrivate::EvCheckSnapshotExpiration, 0,
+                    TActivationContext::Schedule(when, new IEventHandleFat(TEvPrivate::EvCheckSnapshotExpiration, 0,
                         SelfId(), {}, nullptr, when.GetValue()));
                     SnapshotExpirationCheckSchedule.push_front(when);
                 }
diff --git a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp
index 15864a1231b..532b2f2a824 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeletonfront.cpp
@@ -56,7 +56,7 @@ namespace NKikimr {
         template<typename Func>
         void ApplyToRecord(IEventHandle& event, Func&& callback) {
             switch (event.GetTypeRewrite()) {
-#define EVENT_TYPE(EVENT) case TEvBlobStorage::EVENT::EventType: callback(static_cast<TEvBlobStorage::EVENT&>(*event.GetBase()).Record); return;
+#define EVENT_TYPE(EVENT) case TEvBlobStorage::EVENT::EventType: callback(event.CastAsLocal<TEvBlobStorage::EVENT>()->Record); return;
                 EVENT_TYPE(TEvVMovedPatch)
                 EVENT_TYPE(TEvVPatchStart)
                 EVENT_TYPE(TEvVPatchDiff)
@@ -578,7 +578,7 @@ namespace NKikimr {
                         TEvBlobStorage::TEvVWindowChange::DropConnection));
 
                     // small hack for older versions of BS_QUEUE that do not support DropConnection flag
-                    ctx.Send(new IEventHandle(winp->ActorId, serviceId, new TEvents::TEvUndelivered(0,
+                    ctx.Send(new IEventHandleFat(winp->ActorId, serviceId, new TEvents::TEvUndelivered(0,
                         TEvents::TEvUndelivered::ReasonActorUnknown)));
                 };
                 QueueBackpressure->ForEachWindow(callback);
@@ -594,15 +594,14 @@ namespace NKikimr {
             }
 
             void Completed(const TActorContext &ctx, const TVMsgContext &msgCtx, std::unique_ptr<IEventHandle> &evHandle) {
-                IEventBase *ev = evHandle->GetBase();
                 ReturnCookie(evHandle, true);
 
                 TInstant now = TAppData::TimeProvider->Now();
                 Y_VERIFY(msgCtx.ActorId);
                 auto feedback = QueueBackpressure->Processed(msgCtx.ActorId, msgCtx.MsgId, msgCtx.Cost, now);
                 NKikimrBlobStorage::TMsgQoS *msgQoS = nullptr;
-                switch (ev->Type()) {
-#define UPDATE_WINDOW_STATUS(TYPE) case TYPE::EventType: msgQoS = static_cast<TYPE&>(*ev).Record.MutableMsgQoS(); break;
+                switch (evHandle->Type) {
+#define UPDATE_WINDOW_STATUS(TYPE) case TYPE::EventType: msgQoS = evHandle->CastAsLocal<TYPE>()->Record.MutableMsgQoS(); break;
                     // all message types that have MsgQoS structure
                     UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVMovedPatchResult)
                     UPDATE_WINDOW_STATUS(TEvBlobStorage::TEvVPatchFoundParts)
@@ -1678,7 +1677,7 @@ namespace NKikimr {
         }
 
         void HandleCommenceRepl(const TActorContext& /*ctx*/) {
-            TActivationContext::Send(new IEventHandle(TEvBlobStorage::EvCommenceRepl, 0, SkeletonId, SelfId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvBlobStorage::EvCommenceRepl, 0, SkeletonId, SelfId(), nullptr, 0));
         }
 
         void Handle(TEvReportScrubStatus::TPtr ev, const TActorContext& ctx) {
@@ -1853,7 +1852,7 @@ namespace NKikimr {
                 || std::is_same_v<TEv, TEvBlobStorage::TEvVPut>;
 
         template<typename TEventType>
-        void CheckExecute(TAutoPtr<TEventHandle<TEventType>>& ev, const TActorContext& ctx) {
+        void CheckExecute(TAutoPtr<TEventHandleFat<TEventType>>& ev, const TActorContext& ctx) {
             if constexpr (IsPatchEvent<TEventType>) {
                 HandlePatchEvent(ev);
             } else if constexpr (IsWithoutQoS<TEventType>) {
@@ -1875,7 +1874,7 @@ namespace NKikimr {
         static constexpr bool IsWithoutVDiskId = std::is_same_v<TEv, Decayed>;
 
         template <typename TEventType>
-        void Check(TAutoPtr<TEventHandle<TEventType>>& ev, const TActorContext& ctx) {
+        void Check(TAutoPtr<TEventHandleFat<TEventType>>& ev, const TActorContext& ctx) {
             const auto& record = ev->Get()->Record;
             bool isSameVDisk = true;
             if constexpr (!IsWithoutVDiskId<TEventType>) {
@@ -1892,7 +1891,7 @@ namespace NKikimr {
         }
 
         template<typename TEv>
-        void ValidateEvent(TAutoPtr<TEventHandle<TEv>>& ev, const TActorContext& ctx) {
+        void ValidateEvent(TAutoPtr<TEventHandleFat<TEv>>& ev, const TActorContext& ctx) {
             TString errorReason;
             bool isQueryValid = Validate(ev->Get(), errorReason);
             if (!isQueryValid) {
@@ -1903,7 +1902,7 @@ namespace NKikimr {
         };
 
         void ForwardToSkeleton(STFUNC_SIG) {
-            ctx.Send(ev->Forward(SkeletonId));
+            ctx.Forward(ev, SkeletonId);
         }
 
         void HandleForwardToSkeleton(STFUNC_SIG) {
@@ -1960,7 +1959,7 @@ namespace NKikimr {
 #define HFuncStatus(TEvType, status, errorReason, now, wstatus) \
     case TEvType::EventType: \
     { \
-        TEvType::TPtr x(static_cast<TEventHandle<TEvType>*>(ev.release())); \
+        TEvType::TPtr x(static_cast<TEventHandleFat<TEvType>*>(ev.release())); \
         Reply(x, ctx, status, errorReason, now, wstatus); \
         break; \
     }
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp
index f22c213961b..fb0c751bb3f 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_loggedrec.cpp
@@ -238,7 +238,7 @@ namespace NKikimr {
     void TLoggedRecPhantoms::Replay(THull &hull, const TActorContext &ctx) {
         TEvDetectedPhantomBlob *msg = OrigEv->Get();
         hull.CollectPhantoms(ctx, msg->Phantoms, Seg);
-        TActivationContext::Send(new IEventHandle(TEvBlobStorage::EvDetectedPhantomBlobCommitted, 0, OrigEv->Sender, {},
+        TActivationContext::Send(new IEventHandleFat(TEvBlobStorage::EvDetectedPhantomBlobCommitted, 0, OrigEv->Sender, {},
             nullptr, OrigEv->Cookie));
     }
 
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp
index b9e74248389..d13ae6c169f 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.cpp
@@ -19,7 +19,7 @@ namespace NKikimr {
             TItem() = default;
 
             template<typename T>
-            TItem(TAutoPtr<TEventHandle<T>> ev)
+            TItem(TAutoPtr<TEventHandleFat<T>> ev)
                 : Ev(ev.Release())
                 , Span(TWilson::VDiskInternals, std::move(Ev->TraceId), "VDisk.Skeleton.EmergencyQueue")
             {
@@ -240,7 +240,7 @@ namespace NKikimr {
     }
 
     template <class TEv>
-    inline bool TOverloadHandler::PostponeEvent(TAutoPtr<TEventHandle<TEv>> &ev) {
+    inline bool TOverloadHandler::PostponeEvent(TAutoPtr<TEventHandleFat<TEv>> &ev) {
         if (DynamicPDiskWeightsManager->StopPuts() || !EmergencyQueue->Empty()) {
             EmergencyQueue->Push(ev);
             return true;
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h
index a20d375ef59..85fa455ea59 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_overload_handler.h
@@ -79,7 +79,7 @@ namespace NKikimr {
 
         // Postpone event in case of overload
         template<typename TEv>
-        bool PostponeEvent(TAutoPtr<TEventHandle<TEv>> &ev);
+        bool PostponeEvent(TAutoPtr<TEventHandleFat<TEv>> &ev);
 
         static void ToWhiteboard(const TOverloadHandler *this_, NKikimrWhiteboard::TVDiskSatisfactionRank &v);
         ui32 GetIntegralRankPercent() const;
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp
index 39e8b44fa77..2c2e9aa803a 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor.cpp
@@ -733,7 +733,7 @@ namespace NKikimr::NPrivate {
                 hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle)
                 hFunc(TEvBlobStorage::TEvVPatchDiff, HandleForceEnd)
                 hFunc(TKikimrEvents::TEvWakeup, HandleInStartState)
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << TypeName(*ev->GetBase()));
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ev->GetTypeName());
             }
         }
 
@@ -742,7 +742,7 @@ namespace NKikimr::NPrivate {
                 hFunc(TEvBlobStorage::TEvVPatchDiff, Handle)
                 hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle)
                 hFunc(TKikimrEvents::TEvWakeup, HandleInWaitState)
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << TypeName(*ev->GetBase()));
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ev->GetTypeName());
             }
         }
 
@@ -753,7 +753,7 @@ namespace NKikimr::NPrivate {
                 IgnoreFunc(TEvBlobStorage::TEvVPatchXorDiffResult)
                 hFunc(TKikimrEvents::TEvWakeup, HandleInWaitState)
                 sFunc(TEvVPatchDyingConfirm, PassAway)
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << TypeName(*ev->GetBase()));
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ev->GetTypeName());
             }
         }
 
@@ -763,7 +763,7 @@ namespace NKikimr::NPrivate {
                 hFunc(TEvBlobStorage::TEvVPutResult, Handle)
                 IgnoreFunc(TEvBlobStorage::TEvVPatchXorDiffResult)
                 hFunc(TKikimrEvents::TEvWakeup, HandleInDataStates)
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << TypeName(*ev->GetBase()));
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ev->GetTypeName());
             }
         }
 
@@ -773,7 +773,7 @@ namespace NKikimr::NPrivate {
                 hFunc(TEvBlobStorage::TEvVPutResult, Handle)
                 hFunc(TEvBlobStorage::TEvVPatchXorDiff, Handle)
                 hFunc(TKikimrEvents::TEvWakeup, HandleInParityStates)
-                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << TypeName(*ev->GetBase()));
+                default: Y_FAIL_S(VDiskLogPrefix << " unexpected event " << ev->GetTypeName());
             }
         }
     };
diff --git a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp
index fc795731728..767ff4241c5 100644
--- a/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp
+++ b/ydb/core/blobstorage/vdisk/skeleton/skeleton_vpatch_actor_ut.cpp
@@ -51,14 +51,14 @@ namespace NKikimr {
         virtual ~TVPatchDecorator() {
             if (NActors::TlsActivationContext) {
                 std::unique_ptr<IEventBase> ev = std::make_unique<TEvRequestEnd>();
-                std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(EdgeActor, EdgeActor, ev.release());
+                std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandleFat>(EdgeActor, EdgeActor, ev.release());
                 TActivationContext::Send(handle.release());
             }
         }
 
         bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
-            if (ev->GetBase()) {
-                Cerr << "Send " << TypeName(*ev->GetBase()) << Endl;
+            if (ev->HasEvent()) {
+                Cerr << "Send " << ev->GetTypeName() << Endl;
             } else {
                 Cerr << "Send " << ev->Type << Endl;
             }
@@ -76,8 +76,8 @@ namespace NKikimr {
                 PassAway();
                 return false;
             }
-            if (ev->GetBase()) {
-                Cerr << "Recv " << TypeName(*ev->GetBase()) << Endl;
+            if (ev->HasEvent()) {
+                Cerr << "Recv " << ev->GetTypeName() << Endl;
             } else {
                 Cerr << "Recv " << ev->Type << Endl;
             }
@@ -210,7 +210,7 @@ namespace NKikimr {
             std::unique_ptr<IEventHandle> handle;
             ui32 nodeCount = Runtime.GetNodeCount();
             for (ui32 nodeId = 0; nodeId < nodeCount; ++nodeId) {
-                handle = std::make_unique<IEventHandle>(VPatchActorIds[nodeId], EdgeActors[nodeId],
+                handle = std::make_unique<IEventHandleFat>(VPatchActorIds[nodeId], EdgeActors[nodeId],
                         new NActors::TEvents::TEvPoisonPill);
                 Runtime.Send(handle.release());
             }
@@ -222,7 +222,7 @@ namespace NKikimr {
     typename EventType::TPtr CreateEventHandle(const TActorId &recipient, const TActorId &sender,
             std::unique_ptr<EventType> &&ev)
     {
-        return static_cast<TEventHandle<EventType>*>(new IEventHandle(recipient, sender, ev.release()));
+        return static_cast<TEventHandleFat<EventType>*>(new IEventHandleFat(recipient, sender, ev.release()));
     }
 
 
@@ -275,7 +275,7 @@ namespace NKikimr {
             for (ui8 partId : foundParts) {
                 evVGetRangeResult->Record.MutableResult(0)->AddParts(partId);
             }
-            handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, evVGetRangeResult.release());
+            handle = new IEventHandleFat(vPatchActorId, edgeActor, evVGetRangeResult.release());
             runtime.Send(handle.Release());
 
             auto evVPatchFoundParts = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchFoundParts>(handle);
@@ -319,19 +319,19 @@ namespace NKikimr {
             TAutoPtr<IEventHandle> handle;
             if (!isKilled) {
                 std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateForceEndVPatchDiff(1, 0);
-                handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, diff.release());
+                handle = new IEventHandleFat(vPatchActorId, edgeActor, diff.release());
                 testData.Runtime.Send(handle.Release());
 
                 auto result = testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle);
                 UNIT_ASSERT(result->Record.GetStatus() == NKikimrProto::OK);
                 auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
                 UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId);
-                handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+                handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
                 testData.Runtime.Send(handle.Release());
             } else {
                 auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
                 UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId);
-                handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+                handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
                 testData.Runtime.Send(handle.Release());
             }
 
@@ -419,7 +419,7 @@ namespace NKikimr {
 
             auto dyingRequest = runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
             UNIT_ASSERT_VALUES_EQUAL(dyingRequest->PatchedBlobId, testData.PatchedBlobId);
-            handle = MakeHolder<IEventHandle>(actorId, edgeActor, new TEvVPatchDyingConfirm);
+            handle = new IEventHandleFat(actorId, edgeActor, new TEvVPatchDyingConfirm);
             testData.Runtime.Send(handle.Release());
             testData.WaitEndTest();
         }
@@ -442,7 +442,7 @@ namespace NKikimr {
                     nullptr, nullptr, nullptr, evVGet->Record.GetCookie(), vGetHandle->GetChannel(), 0);
             evVGetResult->AddResult(NKikimrProto::OK, blob.BlobId, 0, blob.Buffer.data(), blob.Buffer.size());
 
-            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(vPatchActorId, edgeActor, evVGetResult.release());
+            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandleFat>(vPatchActorId, edgeActor, evVGetResult.release());
             runtime.Send(handle.release());
 
             return vGetStatus != NKikimrProto::OK;
@@ -470,7 +470,7 @@ namespace NKikimr {
                     vPutStatus, blobId, testData.VDiskIds[nodeId], &cookie, oos, testData.Now,
                     0, &record, nullptr, nullptr, nullptr, vPut->GetBufferBytes(), 0, "");
 
-            handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, vPutResult.release());
+            handle = new IEventHandleFat(vPatchActorId, edgeActor, vPutResult.release());
             runtime.Send(handle.Release());
             return true;
         }
@@ -501,7 +501,7 @@ namespace NKikimr {
             std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(pullingPart, false, {}, 0);
             TAutoPtr<IEventHandle> handle;
 
-            handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, diff.release());
+            handle = new IEventHandleFat(vPatchActorId, edgeActor, diff.release());
             runtime.Send(handle.Release());
             TBlob pullingBlob(testData.OriginalBlobId, pullingPart, partSize);
 
@@ -509,7 +509,7 @@ namespace NKikimr {
             if (isKilled) {
                 auto result = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchResult>(handle);
                 UNIT_ASSERT(result->Record.GetStatus() == NKikimrProto::ERROR);
-                handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+                handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
                 runtime.Send(handle.Release());
                 testData.WaitEndTest();
                 return;
@@ -529,7 +529,7 @@ namespace NKikimr {
 
             auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
             UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId);
-            handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+            handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
             testData.Runtime.Send(handle.Release());
             testData.WaitEndTest();
         }
@@ -609,7 +609,7 @@ namespace NKikimr {
                 xorDiff->AddDiff(diff.Offset, diff.Buffer);
             }
 
-            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandle>(vPatchActorId, edgeActor, xorDiff.release());
+            std::unique_ptr<IEventHandle> handle = std::make_unique<IEventHandleFat>(vPatchActorId, edgeActor, xorDiff.release());
             runtime.Send(handle.release());
         }
 
@@ -644,19 +644,19 @@ namespace NKikimr {
             std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, 1, {}, 0);
             std::unique_ptr<IEventHandle> handle;
 
-            handle = std::make_unique<IEventHandle>(vPatchActorId, edgeActor, diff.release());
+            handle = std::make_unique<IEventHandleFat>(vPatchActorId, edgeActor, diff.release());
             runtime.Send(handle.release());
 
             if (status != NKikimrProto::OK) {
                 TAutoPtr<IEventHandle> handle;
                 testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiffResult>(handle);
                 ReceiveVPatchResult(testData, status);
-                handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+                handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
                 runtime.Send(handle.Release());
 
                 auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
                 UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId);
-                handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+                handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
                 testData.Runtime.Send(handle.Release());
 
                 testData.WaitEndTest();
@@ -769,7 +769,7 @@ namespace NKikimr {
                     TAutoPtr<IEventHandle> handle;
                     auto diyngRequest = testData.Runtime.GrabEdgeEventRethrow<TEvVPatchDyingRequest>(handle);
                     UNIT_ASSERT(diyngRequest->PatchedBlobId == testData.PatchedBlobId);
-                    handle = MakeHolder<IEventHandle>(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
+                    handle = new IEventHandleFat(vPatchActorId, edgeActor, new TEvVPatchDyingConfirm);
                     testData.Runtime.Send(handle.Release());
                 }
             }
@@ -788,7 +788,7 @@ namespace NKikimr {
                 }
 
                 std::unique_ptr<IEventHandle> handle;
-                handle = std::make_unique<IEventHandle>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
+                handle = std::make_unique<IEventHandleFat>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
                         diff.release());
                 testData.Runtime.Send(handle.release());
                 dataDiffCount++;
@@ -806,7 +806,7 @@ namespace NKikimr {
                     std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, dataDiffCount,
                             {}, 0, partIdx);
                     std::unique_ptr<IEventHandle> handle;
-                    handle = std::make_unique<IEventHandle>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
+                    handle = std::make_unique<IEventHandleFat>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
                             diff.release());
                     testData.Runtime.Send(handle.release());
                 }
@@ -838,7 +838,7 @@ namespace NKikimr {
                     }
 
                     TActorId patchActor = testData.VPatchActorIds[patchedPartId - 1];
-                    auto handle2 = std::make_unique<IEventHandle>(patchActor, edgeActor, handle->Release().Release(), handle->Flags,
+                    auto handle2 = std::make_unique<IEventHandleFat>(patchActor, edgeActor, handle->Release().Release(), handle->Flags,
                             handle->Cookie, nullptr);
                     testData.Runtime.Send(handle2.release());
                     testData.Runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVPatchXorDiffResult>({edgeActor});
@@ -855,7 +855,7 @@ namespace NKikimr {
                     std::unique_ptr<TEvBlobStorage::TEvVPatchDiff> diff = testData.CreateVPatchDiff(partId, dataDiffCount,
                             {}, 0, partIdx);
                     std::unique_ptr<IEventHandle> handle;
-                    handle = std::make_unique<IEventHandle>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
+                    handle = std::make_unique<IEventHandleFat>(testData.VPatchActorIds[partIdx], testData.EdgeActors[partIdx],
                             diff.release());
                     testData.Runtime.Send(handle.release());
                 }
diff --git a/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_localwriter.cpp b/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_localwriter.cpp
index b7ade7f8314..1746923c38e 100644
--- a/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_localwriter.cpp
+++ b/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_localwriter.cpp
@@ -160,7 +160,7 @@ namespace NKikimr {
                     << " dataSize# " << Ev->Data.size()
                     << " duration# %s" << (finishTime - startTime));
 
-            ctx.Send(new IEventHandle(SkeletonId, ParentId, Ev.release()));
+            ctx.Send(new IEventHandleFat(SkeletonId, ParentId, Ev.release()));
             PassAway();
         }
 
diff --git a/ydb/core/client/client_ut.cpp b/ydb/core/client/client_ut.cpp
index 3c4bf38832c..cf811ebbb7d 100644
--- a/ydb/core/client/client_ut.cpp
+++ b/ydb/core/client/client_ut.cpp
@@ -2098,14 +2098,14 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, ui64(10)));
-            runtime.Send(new IEventHandle(leaderId, edge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, edge, reqWrite.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
         }
 
         {
-            runtime.Send(new IEventHandle(leaderTablet, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(leaderTablet, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
@@ -2113,7 +2113,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(readQuery);
-            runtime.Send(new IEventHandle(followerId, edge, reqRead.Release()));
+            runtime.Send(new IEventHandleFat(followerId, edge, reqRead.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2157,7 +2157,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             const TActorId leaderId = runtime.GrabEdgeEvent<TEvTablet::TEvRestored>(edge)->Get()->UserTabletActor;
             Y_UNUSED(leaderId);
 
-            runtime.Send(new IEventHandle(leaderTablet, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(leaderTablet, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
@@ -2228,7 +2228,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, ui64(10)));
-            runtime.Send(new IEventHandle(leaderId, edge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, edge, reqWrite.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2237,7 +2237,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(readQuery);
-            runtime.Send(new IEventHandle(followerId, edge, reqRead.Release()));
+            runtime.Send(new IEventHandleFat(followerId, edge, reqRead.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2256,14 +2256,14 @@ Y_UNIT_TEST_SUITE(TClientTest) {
 
         {
             // Kill leader
-            runtime.Send(new IEventHandle(leaderTablet, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(leaderTablet, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
 
         {
             // Kill follower
-            runtime.Send(new IEventHandle(followerTablet, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(followerTablet, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
@@ -2289,7 +2289,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             // Read row from offline follower
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(readQuery);
-            runtime.Send(new IEventHandle(followerId2, edge, reqRead.Release()));
+            runtime.Send(new IEventHandleFat(followerId2, edge, reqRead.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2375,7 +2375,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, ui64(10)));
-            runtime.Send(new IEventHandle(leaderId, edge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, edge, reqWrite.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2384,7 +2384,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(readQuery);
-            runtime.Send(new IEventHandle(followerId, edge, reqRead.Release()));
+            runtime.Send(new IEventHandleFat(followerId, edge, reqRead.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2399,14 +2399,14 @@ Y_UNIT_TEST_SUITE(TClientTest) {
 
         {
             // Kill leader
-            runtime.Send(new IEventHandle(leaderTablet, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(leaderTablet, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
 
         {
             // Kill follower
-            runtime.Send(new IEventHandle(followerTablet, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(followerTablet, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
@@ -2432,7 +2432,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             // Read row from offline follower (unconfirmed commit must be ignored)
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(readQuery);
-            runtime.Send(new IEventHandle(followerId2, edge, reqRead.Release()));
+            runtime.Send(new IEventHandleFat(followerId2, edge, reqRead.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2453,7 +2453,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
 
         {
             // Kill follower 2
-            runtime.Send(new IEventHandle(followerTablet2, edge, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(followerTablet2, edge, new TEvents::TEvPoisonPill()));
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
@@ -2479,7 +2479,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             // Read row from offline follower
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(readQuery);
-            runtime.Send(new IEventHandle(followerId3, edge, reqRead.Release()));
+            runtime.Send(new IEventHandleFat(followerId3, edge, reqRead.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2531,7 +2531,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
 
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, key, value));
-            runtime.Send(new IEventHandle(leaderId, leaderEdge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, leaderEdge, reqWrite.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(leaderEdge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2556,7 +2556,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
 
             THolder<TEvTablet::TEvLocalMKQL> reqRead = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqRead->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(readQuery, key));
-            runtime.Send(new IEventHandle(followerId, followerEdge, reqRead.Release()), 1);
+            runtime.Send(new IEventHandleFat(followerId, followerEdge, reqRead.Release()), 1);
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(followerEdge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2591,7 +2591,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
                     Cerr << "... dropping TEvFollowerDetach" << Endl;
                     ++detachCounter;
                     runtime.Send(
-                        new IEventHandle(
+                        new IEventHandleFat(
                             runtime.GetInterconnectProxy(0, 1),
                             { },
                             new TEvInterconnect::TEvDisconnect()),
@@ -2626,7 +2626,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         {
             // Kill follower
             Cerr << "... killing follower " << followerTablet << Endl;
-            runtime.Send(new IEventHandle(followerTablet, followerEdge, new TEvents::TEvPoisonPill()), 1);
+            runtime.Send(new IEventHandleFat(followerTablet, followerEdge, new TEvents::TEvPoisonPill()), 1);
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvTabletDead>(followerEdge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->TabletID, tabletId);
         }
@@ -2692,7 +2692,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
             TActorId edge = runtime.AllocateEdgeActor();
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, key, value));
-            runtime.Send(new IEventHandle(leaderId, edge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, edge, reqWrite.Release()));
             return edge;
         };
 
@@ -2843,7 +2843,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         for (int i = 0; i < 350; ++i) {
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, ui64(i + 10)));
-            runtime.Send(new IEventHandle(leaderId, edge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, edge, reqWrite.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
@@ -2859,7 +2859,7 @@ Y_UNIT_TEST_SUITE(TClientTest) {
         for (int i = 0; i < 350; ++i) {
             THolder<TEvTablet::TEvLocalMKQL> reqWrite = MakeHolder<TEvTablet::TEvLocalMKQL>();
             reqWrite->Record.MutableProgram()->MutableProgram()->SetText(Sprintf(writeQuery, ui64(i + 10)));
-            runtime.Send(new IEventHandle(leaderId, edge, reqWrite.Release()));
+            runtime.Send(new IEventHandleFat(leaderId, edge, reqWrite.Release()));
 
             auto reply = runtime.GrabEdgeEvent<TEvTablet::TEvLocalMKQLResponse>(edge);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetStatus(), 0);
diff --git a/ydb/core/client/flat_ut.cpp b/ydb/core/client/flat_ut.cpp
index 819f12bfa1c..3ad75577cc6 100644
--- a/ydb/core/client/flat_ut.cpp
+++ b/ydb/core/client/flat_ut.cpp
@@ -2764,7 +2764,7 @@ Y_UNIT_TEST_SUITE(TFlatTest) {
 
         for (auto tabletId : xrange(72075186224037888, 72075186224037893)) {
             cleverServer.GetRuntime()->Send(
-                new IEventHandle(MakeTabletResolverID(), TActorId(),
+                new IEventHandleFat(MakeTabletResolverID(), TActorId(),
                     new TEvTabletResolver::TEvTabletProblem(tabletId, TActorId())
                 ));
         }
diff --git a/ydb/core/client/flat_ut_client.h b/ydb/core/client/flat_ut_client.h
index 07f5b30cc6b..bcd93e65e8a 100644
--- a/ydb/core/client/flat_ut_client.h
+++ b/ydb/core/client/flat_ut_client.h
@@ -64,7 +64,7 @@ public:
         TActorId txProxy = MakeTxProxyID();
         TActorId sender = runtime->AllocateEdgeActor();
         TAutoPtr<TEvTxUserProxy::TEvInvalidateTable> ev(new TEvTxUserProxy::TEvInvalidateTable(tableId));
-        runtime->Send(new IEventHandle(txProxy, sender, ev.Release()));
+        runtime->Send(new IEventHandleFat(txProxy, sender, ev.Release()));
         TAutoPtr<IEventHandle> handle;
         auto readSchemeStringResult = runtime->GrabEdgeEventRethrow<TEvTxUserProxy::TEvInvalidateTableResult>(handle);
         Y_UNUSED(readSchemeStringResult);
@@ -74,14 +74,14 @@ public:
         TTestActorRuntime* runtime = server.GetRuntime();
         TActorId sender = runtime->AllocateEdgeActor();
 
-        runtime->Send(new IEventHandle(MakeTabletResolverID(), sender, new TEvTabletResolver::TEvTabletProblem(tabletId, TActorId())));
-        runtime->Send(new IEventHandle(MakeTabletResolverID(), sender, new TEvTabletResolver::TEvForward(tabletId, nullptr)));
+        runtime->Send(new IEventHandleFat(MakeTabletResolverID(), sender, new TEvTabletResolver::TEvTabletProblem(tabletId, TActorId())));
+        runtime->Send(new IEventHandleFat(MakeTabletResolverID(), sender, new TEvTabletResolver::TEvForward(tabletId, nullptr)));
 
         TAutoPtr<IEventHandle> handle;
         auto forwardResult = runtime->GrabEdgeEventRethrow<TEvTabletResolver::TEvForwardResult>(handle);
         UNIT_ASSERT(forwardResult && forwardResult->Tablet);
-        runtime->Send(new IEventHandle(forwardResult->Tablet, sender, new TEvents::TEvPoisonPill()));
-        runtime->Send(new IEventHandle(MakeTabletResolverID(), sender, new TEvTabletResolver::TEvTabletProblem(tabletId, TActorId())));
+        runtime->Send(new IEventHandleFat(forwardResult->Tablet, sender, new TEvents::TEvPoisonPill()));
+        runtime->Send(new IEventHandleFat(MakeTabletResolverID(), sender, new TEvTabletResolver::TEvTabletProblem(tabletId, TActorId())));
     }
 
     TVector<ui64> GetTablePartitions(const TString& tablePath) {
diff --git a/ydb/core/client/locks_ut.cpp b/ydb/core/client/locks_ut.cpp
index 11b76611e30..3564fcc16b3 100644
--- a/ydb/core/client/locks_ut.cpp
+++ b/ydb/core/client/locks_ut.cpp
@@ -52,7 +52,7 @@ public:
         TActorId txProxy = MakeTxProxyID();
         TActorId sender = runtime->AllocateEdgeActor();
         TAutoPtr<TEvTxUserProxy::TEvInvalidateTable> ev(new TEvTxUserProxy::TEvInvalidateTable(tableId));
-        runtime->Send(new IEventHandle(txProxy, sender, ev.Release()));
+        runtime->Send(new IEventHandleFat(txProxy, sender, ev.Release()));
         TAutoPtr<IEventHandle> handle;
         auto readSchemeStringResult = runtime->GrabEdgeEventRethrow<TEvTxUserProxy::TEvInvalidateTableResult>(handle);
         Y_UNUSED(readSchemeStringResult);
diff --git a/ydb/core/client/minikql_compile/mkql_compile_service.cpp b/ydb/core/client/minikql_compile/mkql_compile_service.cpp
index 8179bc4a042..c026080104f 100644
--- a/ydb/core/client/minikql_compile/mkql_compile_service.cpp
+++ b/ydb/core/client/minikql_compile/mkql_compile_service.cpp
@@ -120,7 +120,7 @@ private:
         if (!hasErrors || cptr->Retried || cptr->ForceRefresh) {
             auto* compileStatusEv = new TMiniKQLCompileServiceEvents::TEvCompileStatus(cptr->Program, msg->Result);
             compileStatusEv->CompileResolveCookies = std::move(msg->CompileResolveCookies);
-            ctx.ExecutorThread.Send(new IEventHandle(cptr->ResponseTo, ctx.SelfID, compileStatusEv,
+            ctx.ExecutorThread.Send(new IEventHandleFat(cptr->ResponseTo, ctx.SelfID, compileStatusEv,
                 0, cptr->Cookie));
             Compile(ctx);
         } else {
diff --git a/ydb/core/client/minikql_compile/yql_expr_minikql.cpp b/ydb/core/client/minikql_compile/yql_expr_minikql.cpp
index 9224f16eab6..290b966d5a6 100644
--- a/ydb/core/client/minikql_compile/yql_expr_minikql.cpp
+++ b/ydb/core/client/minikql_compile/yql_expr_minikql.cpp
@@ -1607,7 +1607,7 @@ private:
 
     void SendResponseAndDie(const TMiniKQLCompileResult& result, THashMap<TString, ui64> &&resolveCookies, const TActorContext& ctx) {
         ctx.ExecutorThread.Send(
-            new IEventHandle(
+            new IEventHandleFat(
                 ResponseTo,
                 ctx.SelfID,
                 new TMiniKQLCompileActorEvents::TEvCompileResult(result, std::move(resolveCookies))
diff --git a/ydb/core/client/server/msgbus_securereq.h b/ydb/core/client/server/msgbus_securereq.h
index 5e68ca0eeb2..3265bc875a0 100644
--- a/ydb/core/client/server/msgbus_securereq.h
+++ b/ydb/core/client/server/msgbus_securereq.h
@@ -27,6 +27,11 @@ public:
     TMessageBusSecureRequest(Args&&... args)
         : TSecureRequestActor<TMessageBusServerRequestBase<TMessageBusSecureRequest<TMessageBusServerRequestBase<TDerived>>>, TDerived>(std::forward<Args>(args)...)
     {}
+
+    template<typename T>
+    void Become(T stateFunc) {
+        IActorCallback::Become(stateFunc);
+    }
 };
 
 template <typename TDerived, typename TTabletReplyEvent, NKikimrServices::TActivity::EType Activity>
diff --git a/ydb/core/client/server/msgbus_server_cms.cpp b/ydb/core/client/server/msgbus_server_cms.cpp
index 53ada2a3fad..d22d498e963 100644
--- a/ydb/core/client/server/msgbus_server_cms.cpp
+++ b/ydb/core/client/server/msgbus_server_cms.cpp
@@ -283,7 +283,7 @@ public:
         default:
             Y_FAIL("TCmsRequestActor::MainState unexpected event type: %" PRIx32 " event: %s",
                    ev->GetTypeRewrite(),
-                   ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/client/server/msgbus_server_console.cpp b/ydb/core/client/server/msgbus_server_console.cpp
index 0da13ed4a12..03eb2dfb6f7 100644
--- a/ydb/core/client/server/msgbus_server_console.cpp
+++ b/ydb/core/client/server/msgbus_server_console.cpp
@@ -344,7 +344,7 @@ public:
         default:
             Y_FAIL("TConsoleRequestActor::MainState unexpected event type: %" PRIx32 " event: %s",
                    ev->GetTypeRewrite(),
-                   ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/client/server/msgbus_server_persqueue.cpp b/ydb/core/client/server/msgbus_server_persqueue.cpp
index a7de796c8f5..54955059ef7 100644
--- a/ydb/core/client/server/msgbus_server_persqueue.cpp
+++ b/ydb/core/client/server/msgbus_server_persqueue.cpp
@@ -484,7 +484,7 @@ STFUNC(TTopicInfoBasedActor::StateFunc) {
     switch (ev->GetTypeRewrite()) {
         CFunc(NActors::TEvents::TSystem::PoisonPill, Die);
     default:
-        LOG_WARN_S(ctx, NKikimrServices::PERSQUEUE, "Unexpected event type: " << ev->GetTypeRewrite() << ", " << (ev->HasEvent() ? ev->GetBase()->ToString() : "<no data>"));
+        LOG_WARN_S(ctx, NKikimrServices::PERSQUEUE, "Unexpected event type: " << ev->GetTypeRewrite() << ", " << ev->ToString());
     }
 }
 
diff --git a/ydb/core/client/server/msgbus_server_persqueue.h b/ydb/core/client/server/msgbus_server_persqueue.h
index 720527078a6..97d5e39fb3f 100644
--- a/ydb/core/client/server/msgbus_server_persqueue.h
+++ b/ydb/core/client/server/msgbus_server_persqueue.h
@@ -182,6 +182,11 @@ protected:
 
     STFUNC(StateFunc);
 
+    template<typename T>
+    void Become(T stateFunc) {
+        IActorCallback::Become(stateFunc);
+    }
+
 protected:
     TActorId SchemeCache;
     TSchemeEntry SchemeEntry;
@@ -315,7 +320,7 @@ protected:
             HFunc(TPipeEvent, HandlePipeEvent);
             CFunc(NActors::TEvents::TSystem::PoisonPill, Die);
         default:
-            LOG_WARN_S(ctx, NKikimrServices::PERSQUEUE, "Unexpected event type: " << ev->GetTypeRewrite() << ", " << (ev->HasEvent() ? ev->GetBase()->ToString() : "<no data>"));
+            LOG_WARN_S(ctx, NKikimrServices::PERSQUEUE, "Unexpected event type: " << ev->GetTypeRewrite() << ", " << ev->ToString());
         }
     }
 
@@ -326,7 +331,7 @@ protected:
             HFunc(TEvTabletPipe::TEvClientConnected, HandlePipeEvent);
             CFunc(NActors::TEvents::TSystem::PoisonPill, Die);
         default:
-            LOG_WARN_S(ctx, NKikimrServices::PERSQUEUE, "Unexpected event type: " << ev->GetTypeRewrite() << ", " << (ev->HasEvent() ? ev->GetBase()->ToString() : "<no data>"));
+            LOG_WARN_S(ctx, NKikimrServices::PERSQUEUE, "Unexpected event type: " << ev->GetTypeRewrite() << ", " << ev->ToString());
         }
     }
 
diff --git a/ydb/core/cms/cms.cpp b/ydb/core/cms/cms.cpp
index ad24eeb8446..a8164058c4b 100644
--- a/ydb/core/cms/cms.cpp
+++ b/ydb/core/cms/cms.cpp
@@ -415,7 +415,7 @@ bool TCms::CheckActionShutdownNode(const NKikimrCms::TAction &action,
         return false;
     }
 
-    if (!AppData(ctx)->DisableCheckingSysNodesCms && 
+    if (!AppData(ctx)->DisableCheckingSysNodesCms &&
         !CheckSysTabletsNode(action, opts, node, error)) {
         return false;
     }
@@ -478,7 +478,7 @@ bool TCms::TryToLockStateStorageReplica(const TAction& action,
                                         const TActionOptions& opts,
                                         const TNodeInfo& node,
                                         TErrorInfo& error,
-                                        const TActorContext &ctx) const 
+                                        const TActorContext &ctx) const
 {
     TInstant defaultDeadline = TActivationContext::Now() + State->Config.DefaultRetryTime;
 
@@ -503,7 +503,7 @@ bool TCms::TryToLockStateStorageReplica(const TAction& action,
     TDuration duration = TDuration::MicroSeconds(action.GetDuration()) + opts.PermissionDuration;
     for (auto ringInfo : ClusterInfo->StateStorageRings) {
         auto state = ringInfo->CountState(now, State->Config.DefaultRetryTime, duration);
-        LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::CMS, "Ring: " << ringInfo->RingId 
+        LOG_DEBUG_S(*TlsActivationContext, NKikimrServices::CMS, "Ring: " << ringInfo->RingId
                                                                  << "; State: " << TStateStorageRingInfo::RingStateToString(state));
 
         if (ringInfo->RingId == currentRing) {
@@ -539,9 +539,9 @@ bool TCms::TryToLockStateStorageReplica(const TAction& action,
             if (restartRings + lockedRings > 1) {
                 error.Code = TStatus::DISALLOW_TEMP;
                 error.Reason = TStringBuilder() << "Too many unavailable state storage rings"
-                                                << ". Restarting rings: " 
+                                                << ". Restarting rings: "
                                                     << (currentRingState == TStateStorageRingInfo::Restart ? restartRings : restartRings - 1)
-                                                << ". Temporary (for a 2 minutes) locked rings: " 
+                                                << ". Temporary (for a 2 minutes) locked rings: "
                                                     << (currentRingState == TStateStorageRingInfo::Locked ? lockedRings + 1 : lockedRings)
                                                 << ". Maximum allowed number of unavailable rings for this mode: " << 1;
                 error.Deadline = defaultDeadline;
@@ -552,9 +552,9 @@ bool TCms::TryToLockStateStorageReplica(const TAction& action,
             if (restartRings + lockedRings + disabledRings > (nToSelect - 1) / 2) {
                 error.Code = TStatus::DISALLOW_TEMP;
                 error.Reason = TStringBuilder() << "Too many unavailable state storage rings"
-                                                << ". Restarting rings: " 
+                                                << ". Restarting rings: "
                                                     << (currentRingState == TStateStorageRingInfo::Restart ? restartRings : restartRings - 1)
-                                                << ". Temporary (for a 2 minutes) locked rings: " 
+                                                << ". Temporary (for a 2 minutes) locked rings: "
                                                     << (currentRingState == TStateStorageRingInfo::Locked ? lockedRings + 1 : lockedRings)
                                                 << ". Disabled rings: " << disabledRings
                                                 << ". Maximum allowed number of unavailable rings for this mode: " << (nToSelect - 1) / 2;
@@ -577,38 +577,38 @@ bool TCms::TryToLockStateStorageReplica(const TAction& action,
 }
 
 bool TCms::CheckSysTabletsNode(const TAction &action,
-                               const TActionOptions &opts, 
-                               const TNodeInfo &node, 
+                               const TActionOptions &opts,
+                               const TNodeInfo &node,
                                TErrorInfo &error) const
-{ 
+{
     if (node.Services & EService::DynamicNode || node.PDisks.size()) {
         return true;
     }
-    
+
     for (auto &tabletType : ClusterInfo->NodeToTabletTypes[node.NodeId]) {
             ui32 disabledNodesCnt = 1; // сounting including this node
             TErrorInfo err;
             TDuration duration = TDuration::MicroSeconds(action.GetDuration()) + opts.PermissionDuration;
             TInstant defaultDeadline = TActivationContext::Now() + State->Config.DefaultRetryTime;
-            
+
             for (auto &nodeId : ClusterInfo->TabletTypeToNodes[tabletType]) {
                 if (nodeId == node.NodeId) {
                     continue;
                 }
-                if (ClusterInfo->Node(nodeId).IsLocked(err, State->Config.DefaultRetryTime, 
-                                                       TActivationContext::Now(), duration) || 
+                if (ClusterInfo->Node(nodeId).IsLocked(err, State->Config.DefaultRetryTime,
+                                                       TActivationContext::Now(), duration) ||
                     ClusterInfo->Node(nodeId).IsDown(err, defaultDeadline))
-                { 
+                {
                     ++disabledNodesCnt;
                 }
             }
-            
+
             ui32 tabletNodes = ClusterInfo->TabletTypeToNodes[tabletType].size();
             switch (opts.AvailabilityMode) {
                 case MODE_MAX_AVAILABILITY:
                     if (tabletNodes > 1 && disabledNodesCnt * 2 > tabletNodes){
                         error.Code = TStatus::DISALLOW_TEMP;
-                        error.Reason = TStringBuilder() << NKikimrConfig::TBootstrap_ETabletType_Name(tabletType) 
+                        error.Reason = TStringBuilder() << NKikimrConfig::TBootstrap_ETabletType_Name(tabletType)
                                                         << " has too many locked nodes: " << disabledNodesCnt
                                                         << " limit: " << tabletNodes / 2 << " (50%)";
                         error.Deadline = defaultDeadline;
@@ -618,7 +618,7 @@ bool TCms::CheckSysTabletsNode(const TAction &action,
                 case MODE_KEEP_AVAILABLE:
                     if (tabletNodes > 1 && disabledNodesCnt > tabletNodes - 1) {
                         error.Code = TStatus::DISALLOW_TEMP;
-                        error.Reason = TStringBuilder() << NKikimrConfig::TBootstrap_ETabletType_Name(tabletType) 
+                        error.Reason = TStringBuilder() << NKikimrConfig::TBootstrap_ETabletType_Name(tabletType)
                                                         << " has too many locked nodes: " << disabledNodesCnt
                                                         << ". At least one node must be available";
                         error.Deadline = defaultDeadline;
@@ -636,7 +636,7 @@ bool TCms::CheckSysTabletsNode(const TAction &action,
                     return false;
             }
     }
- 
+
     return true;
 }
 
@@ -976,7 +976,7 @@ void TCms::ScheduleLogCleanup(const TActorContext &ctx)
 {
     LogCleanupTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
     CreateLongTimer(ctx, TDuration::Minutes(10),
-                    new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvCleanupLog),
+                    new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvCleanupLog),
                     AppData(ctx)->SystemPoolId,
                     LogCleanupTimerCookieHolder.Get());
 }
@@ -1042,7 +1042,7 @@ void TCms::CleanupWalleTasks(const TActorContext &ctx)
 
     WalleCleanupTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
     CreateLongTimer(ctx, State->Config.DefaultWalleCleanupPeriod,
-                    new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvCleanupWalle),
+                    new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvCleanupWalle),
                     AppData(ctx)->SystemPoolId,
                     WalleCleanupTimerCookieHolder.Get());
 }
@@ -1196,7 +1196,7 @@ void TCms::RemovePermission(TEvCms::TEvManagePermissionRequest::TPtr &ev, bool d
               TStatus::ECode_Name(resp->Record.GetStatus().GetCode()).data(), resp->Record.GetStatus().GetReason().data());
 
     if (!rec.GetDryRun() && resp->Record.GetStatus().GetCode() == TStatus::OK) {
-        auto handle = new IEventHandle(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
+        auto handle = new IEventHandleFat(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
         Execute(CreateTxRemovePermissions(std::move(ids), std::move(ev->Release()), handle), ctx);
     } else {
         Reply(ev, std::move(resp), ctx);
@@ -1268,7 +1268,7 @@ void TCms::RemoveRequest(TEvCms::TEvManageRequestRequest::TPtr &ev, const TActor
               TStatus::ECode_Name(resp->Record.GetStatus().GetCode()).data(), resp->Record.GetStatus().GetReason().data());
 
     if (!rec.GetDryRun() && resp->Record.GetStatus().GetCode() == TStatus::OK) {
-        auto handle = new IEventHandle(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
+        auto handle = new IEventHandleFat(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
         Execute(CreateTxRemoveRequest(id, std::move(ev->Release()), handle), ctx);
     } else {
         Reply(ev, std::move(resp), ctx);
@@ -1346,7 +1346,7 @@ void TCms::EnqueueRequest(TAutoPtr<IEventHandle> ev, const TActorContext &ctx)
     NextQueue.push(ev);
 }
 
-void TCms::StartCollecting(const TActorContext &ctx) 
+void TCms::StartCollecting(const TActorContext &ctx)
 {
     Y_VERIFY(Queue.empty());
     std::swap(NextQueue, Queue);
@@ -1686,7 +1686,7 @@ void TCms::Handle(TEvCms::TEvPermissionRequest::TPtr &ev,
         if (ok)
             AcceptPermissions(resp->Record, reqId, user, ctx);
 
-        auto handle = new IEventHandle(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
+        auto handle = new IEventHandleFat(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
         Execute(CreateTxStorePermissions(std::move(ev->Release()), handle, user, std::move(copy)), ctx);
     }
 }
@@ -1749,7 +1749,7 @@ void TCms::Handle(TEvCms::TEvCheckRequest::TPtr &ev, const TActorContext &ctx)
         if (ok)
             AcceptPermissions(resp->Record, scheduled.RequestId, user, ctx, true);
 
-        auto handle = new IEventHandle(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
+        auto handle = new IEventHandleFat(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
         Execute(CreateTxStorePermissions(std::move(ev->Release()), handle, user, std::move(copy)), ctx);
     }
 }
@@ -1949,7 +1949,7 @@ void TCms::Handle(TEvCms::TEvStoreWalleTask::TPtr &ev, const TActorContext &ctx)
 {
     auto event = ev->Get();
 
-    auto handle = new IEventHandle(ev->Sender, SelfId(), new TEvCms::TEvWalleTaskStored(event->Task.TaskId), 0, ev->Cookie);
+    auto handle = new IEventHandleFat(ev->Sender, SelfId(), new TEvCms::TEvWalleTaskStored(event->Task.TaskId), 0, ev->Cookie);
     Execute(CreateTxStoreWalleTask(event->Task, std::move(ev->Release()), handle), ctx);
 }
 
@@ -1960,7 +1960,7 @@ void TCms::Handle(TEvCms::TEvRemoveWalleTask::TPtr &ev, const TActorContext &ctx
 
     if (State->WalleTasks.contains(id)) {
         auto &task = State->WalleTasks.find(id)->second;
-        auto handle = new IEventHandle(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
+        auto handle = new IEventHandleFat(ev->Sender, SelfId(), resp.Release(), 0, ev->Cookie);
         if (State->ScheduledRequests.contains(task.RequestId)) {
             Execute(CreateTxRemoveRequest(task.RequestId, std::move(ev->Release()), handle), ctx);
         } else {
diff --git a/ydb/core/cms/cms_impl.h b/ydb/core/cms/cms_impl.h
index c5fc9c16842..da0be73e839 100644
--- a/ydb/core/cms/cms_impl.h
+++ b/ydb/core/cms/cms_impl.h
@@ -152,7 +152,7 @@ private:
     }
 
     static void Reply(const IEventBase* request, TAutoPtr<IEventHandle> response, const TActorContext& ctx) {
-        AuditLog(request, response->GetBase(), ctx);
+        AuditLog(request, IEventHandleFat::GetFat(response)->GetBase(), ctx);
         ctx.Send(response);
     }
 
@@ -174,7 +174,7 @@ private:
     STFUNC(StateInit)
     {
         LOG_DEBUG(ctx, NKikimrServices::CMS, "StateInit event type: %" PRIx32 " event: %s",
-                  ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                  ev->GetTypeRewrite(), ev->ToString().data());
         StateInitImpl(ev, ctx);
     }
 
@@ -208,7 +208,7 @@ private:
         default:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_DEBUG(ctx, NKikimrServices::CMS, "StateNotSupported unexpected event type: %" PRIx32 " event: %s",
-                          ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                          ev->GetTypeRewrite(), ev->ToString().data());
             }
         }
     }
@@ -222,7 +222,7 @@ private:
             CFunc(TEvPrivate::EvCleanupExpired, CleanupExpired);
             CFunc(TEvPrivate::EvCleanupLog, CleanupLog);
             CFunc(TEvPrivate::EvCleanupWalle, CleanupWalleTasks);
-            CFunc(TEvPrivate::EvStartCollecting, StartCollecting); 
+            CFunc(TEvPrivate::EvStartCollecting, StartCollecting);
             FFunc(TEvCms::EvClusterStateRequest, EnqueueRequest);
             HFunc(TEvCms::TEvPermissionRequest, CheckAndEnqueueRequest);
             HFunc(TEvCms::TEvManageRequestRequest, Handle);
@@ -255,7 +255,7 @@ private:
         default:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_DEBUG(ctx, NKikimrServices::CMS, "StateWork unexpected event type: %" PRIx32 " event: %s",
-                          ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                          ev->GetTypeRewrite(), ev->ToString().data());
             }
         }
     }
@@ -302,7 +302,7 @@ private:
                                    TErrorInfo &error) const;
     bool CheckSysTabletsNode(const NKikimrCms::TAction &action,
                              const TActionOptions &opts,
-                             const TNodeInfo &node, 
+                             const TNodeInfo &node,
                              TErrorInfo &error) const;
     bool TryToLockNode(const NKikimrCms::TAction &action,
                        const TActionOptions &options,
@@ -322,7 +322,7 @@ private:
                         TErrorInfo &error) const;
     bool TryToLockStateStorageReplica(const NKikimrCms::TAction &action,
                                       const TActionOptions &options,
-                                      const TNodeInfo &node, 
+                                      const TNodeInfo &node,
                                       TErrorInfo& error,
                                       const TActorContext &ctx) const;
     void AcceptPermissions(NKikimrCms::TPermissionResponse &resp, const TString &requestId,
diff --git a/ydb/core/cms/cms_tx_store_walle_task.cpp b/ydb/core/cms/cms_tx_store_walle_task.cpp
index 2b8b1d2cb57..80450a45914 100644
--- a/ydb/core/cms/cms_tx_store_walle_task.cpp
+++ b/ydb/core/cms/cms_tx_store_walle_task.cpp
@@ -22,11 +22,11 @@ public:
     bool Execute(TTransactionContext &txc, const TActorContext &ctx) override
     {
         LOG_DEBUG(ctx, NKikimrServices::CMS, "TTxStoreWalleTask Execute");
-        
+
         for (auto &perm : Task.Permissions) {
             if (Self->State->Permissions.find(perm) == Self->State->Permissions.end()) {
 
-                Response.Reset(new IEventHandle(Response->Recipient, Response->Sender,
+                Response.Reset(new IEventHandleFat(Response->Recipient, Response->Sender,
                                new TEvCms::TEvStoreWalleTaskFailed(Task.TaskId,
                                                                    TStringBuilder() << "There are no stored permissions for this task. "
                                                                                     << "Maybe cleanup ran before task been stored. "
@@ -57,7 +57,7 @@ public:
     }
 
 private:
-    TWalleTaskInfo Task; 
+    TWalleTaskInfo Task;
     THolder<IEventBase> Request;
     TAutoPtr<IEventHandle> Response;
 };
diff --git a/ydb/core/cms/cms_tx_update_config.cpp b/ydb/core/cms/cms_tx_update_config.cpp
index 033a9cf28e7..c9014eb328b 100644
--- a/ydb/core/cms/cms_tx_update_config.cpp
+++ b/ydb/core/cms/cms_tx_update_config.cpp
@@ -82,7 +82,7 @@ ITransaction *TCms::CreateTxUpdateConfig(TEvConsole::TEvConfigNotificationReques
     response->Record.MutableConfigId()->CopyFrom(rec.GetConfigId());
 
     return new TTxUpdateConfig(this, rec.GetConfig().GetCmsConfig(),
-                               new IEventHandle(ev->Sender, ev->Recipient,
+                               new IEventHandleFat(ev->Sender, ev->Recipient,
                                                 response.Release(), 0, ev->Cookie),
                                rec.GetSubscriptionId());
 }
@@ -93,7 +93,7 @@ ITransaction *TCms::CreateTxUpdateConfig(TEvCms::TEvSetConfigRequest::TPtr &ev)
         = new TEvCms::TEvSetConfigResponse;
     response->Record.MutableStatus()->SetCode(NKikimrCms::TStatus::OK);
     return new TTxUpdateConfig(this, ev->Get()->Record.GetConfig(),
-                               new IEventHandle(ev->Sender, ev->Recipient,
+                               new IEventHandleFat(ev->Sender, ev->Recipient,
                                                 response.Release(), 0, ev->Cookie),
                                ConfigSubscriptionId);
 }
diff --git a/ydb/core/cms/cms_ut_common.cpp b/ydb/core/cms/cms_ut_common.cpp
index 2341cd32759..0975a3e031d 100644
--- a/ydb/core/cms/cms_ut_common.cpp
+++ b/ydb/core/cms/cms_ut_common.cpp
@@ -42,7 +42,7 @@ void TFakeNodeWhiteboardService::Handle(TEvConfigsDispatcher::TEvGetConfigReques
                                         const TActorContext &ctx)
 {
     TGuard<TMutex> guard(Mutex);
-    Y_UNUSED(ev); 
+    Y_UNUSED(ev);
     NKikimrConfig::TAppConfig appConfig;
     appConfig.MutableBootstrapConfig()->CopyFrom(BootstrapConfig);
     auto resp = MakeHolder<TEvConfigsDispatcher::TEvGetConfigResponse>();
@@ -372,7 +372,7 @@ inline void AddTablet(NKikimrConfig::TBootstrap::ETabletType type,
 }
 
 static NKikimrConfig::TBootstrap GenerateBootstrapConfig(TTestActorRuntime &runtime,
-                                                         const ui32 nodesCount, 
+                                                         const ui32 nodesCount,
                                                          const TNodeTenantsMap &tenants) {
     NKikimrConfig::TBootstrap res;
 
@@ -527,9 +527,9 @@ static void SetupServices(TTestActorRuntime &runtime,
 
 } // anonymous namespace
 
-TCmsTestEnv::TCmsTestEnv(const TTestEnvOpts &options) 
+TCmsTestEnv::TCmsTestEnv(const TTestEnvOpts &options)
         : TTestBasicRuntime(options.NodeCount, options.DataCenterCount, false)
-        , CmsId(MakeCmsID(0)) 
+        , CmsId(MakeCmsID(0))
 {
     TFakeNodeWhiteboardService::Config.MutableResponse()->SetSuccess(true);
     TFakeNodeWhiteboardService::Config.MutableResponse()->ClearStatus();
@@ -549,7 +549,7 @@ TCmsTestEnv::TCmsTestEnv(const TTestEnvOpts &options)
             ) {
             auto fakeId = NNodeWhiteboard::MakeNodeWhiteboardServiceId(event->Recipient.NodeId());
             if (event->Recipient != fakeId)
-                event = event->Forward(fakeId);
+                IEventHandle::Forward(event, fakeId);
         }
         return TTestActorRuntime::EEventAction::PROCESS;
     };
@@ -575,7 +575,7 @@ TCmsTestEnv::TCmsTestEnv(const TTestEnvOpts &options)
     cmsConfig.MutableTenantLimits()->SetDisabledNodesRatioLimit(0);
     cmsConfig.MutableClusterLimits()->SetDisabledNodesRatioLimit(0);
     SetCmsConfig(cmsConfig);
-    
+
     // Need to allow restart state storage nodes
     AdvanceCurrentTime(TDuration::Minutes(2));
 }
@@ -597,7 +597,7 @@ TCmsTestEnv::TCmsTestEnv(ui32 nodeCount,
 TIntrusiveConstPtr<NKikimr::TStateStorageInfo> TCmsTestEnv::GetStateStorageInfo() {
     ui32 StateStorageGroup = 0;
     const TActorId proxy = MakeStateStorageProxyID(StateStorageGroup);
-    Send(new IEventHandle(proxy, Sender, new TEvStateStorage::TEvListStateStorage()));
+    Send(new IEventHandleFat(proxy, Sender, new TEvStateStorage::TEvListStateStorage()));
 
     auto reply = GrabEdgeEventRethrow<TEvStateStorage::TEvListStateStorageResult>(Sender);
     const auto &rec = reply->Get()->Info;
@@ -851,10 +851,10 @@ TCmsTestEnv::CheckRequest(const TString &user,
 
 
 void TCmsTestEnv::CheckWalleStoreTaskIsFailed(NCms::TEvCms::TEvStoreWalleTask* req)
-{ 
+{
     TString TaskId = req->Task.TaskId;
     SendToPipe(CmsId, Sender, req, 0, GetPipeConfigWithRetries());
-    
+
     TAutoPtr<IEventHandle> handle;
     auto reply = GrabEdgeEventRethrow<TEvCms::TEvStoreWalleTaskFailed>(handle, TDuration::Seconds(30));
     UNIT_ASSERT(reply);
diff --git a/ydb/core/cms/console/config_helpers.cpp b/ydb/core/cms/console/config_helpers.cpp
index 7b436f65bcf..a66dfe3b376 100644
--- a/ydb/core/cms/console/config_helpers.cpp
+++ b/ydb/core/cms/console/config_helpers.cpp
@@ -350,7 +350,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/cms/console/configs_cache.h b/ydb/core/cms/console/configs_cache.h
index fb4e926c7f2..d0a774acc08 100644
--- a/ydb/core/cms/console/configs_cache.h
+++ b/ydb/core/cms/console/configs_cache.h
@@ -31,7 +31,7 @@ public:
             HFuncTraced(TEvents::TEvPoisonPill, Handle);
             default:
                 Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                       ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                       ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/console/configs_cache_ut.cpp b/ydb/core/cms/console/configs_cache_ut.cpp
index 450a95804af..912d2691a33 100644
--- a/ydb/core/cms/console/configs_cache_ut.cpp
+++ b/ydb/core/cms/console/configs_cache_ut.cpp
@@ -157,7 +157,7 @@ Y_UNIT_TEST_SUITE(TConfigsCacheTests) {
         auto edge = runtime.AllocateEdgeActor();
 
         TSaveCallback save = [&runtime, &edge](auto &config) {
-            runtime.Send(new IEventHandle(runtime.Sender, edge, new TEvPrivate::TEvSaveConfig(config)));
+            runtime.Send(new IEventHandleFat(runtime.Sender, edge, new TEvPrivate::TEvSaveConfig(config)));
         };
 
         TLoadCallback load = [](auto&) {};
@@ -186,7 +186,7 @@ Y_UNIT_TEST_SUITE(TConfigsCacheTests) {
         auto edge = runtime.AllocateEdgeActor();
 
         TSaveCallback save = [&runtime, &edge](auto &config) {
-            runtime.Send(new IEventHandle(runtime.Sender, edge, new TEvPrivate::TEvSaveConfig(config)));
+            runtime.Send(new IEventHandleFat(runtime.Sender, edge, new TEvPrivate::TEvSaveConfig(config)));
         };
 
         TLoadCallback load = [](auto&) {};
@@ -267,7 +267,7 @@ Y_UNIT_TEST_SUITE(TConfigsCacheTests) {
         auto edge = runtime.AllocateEdgeActor();
 
         TSaveCallback save = [&runtime, &edge](auto &config) {
-            runtime.Send(new IEventHandle(runtime.Sender, edge, new TEvPrivate::TEvSaveConfig(config)));
+            runtime.Send(new IEventHandleFat(runtime.Sender, edge, new TEvPrivate::TEvSaveConfig(config)));
         };
 
         TLoadCallback load = [](auto&) {};
diff --git a/ydb/core/cms/console/configs_dispatcher.cpp b/ydb/core/cms/console/configs_dispatcher.cpp
index 9a125724d39..770fd56c185 100644
--- a/ydb/core/cms/console/configs_dispatcher.cpp
+++ b/ydb/core/cms/console/configs_dispatcher.cpp
@@ -216,7 +216,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/cms/console/configs_dispatcher_ut.cpp b/ydb/core/cms/console/configs_dispatcher_ut.cpp
index 8c9a26890d9..67690e45d52 100644
--- a/ydb/core/cms/console/configs_dispatcher_ut.cpp
+++ b/ydb/core/cms/console/configs_dispatcher_ut.cpp
@@ -245,7 +245,7 @@ TActorId AddSubscriber(TTenantTestRuntime &runtime, TVector<ui32> kinds, bool ho
 NKikimrConfig::TAppConfig GetConfig(TTenantTestRuntime &runtime, TVector<ui32> kinds, bool cache = true)
 {
     TAutoPtr<IEventHandle> handle;
-    runtime.Send(new IEventHandle(MakeConfigsDispatcherID(runtime.GetNodeId(0)),
+    runtime.Send(new IEventHandleFat(MakeConfigsDispatcherID(runtime.GetNodeId(0)),
                                   runtime.Sender,
                                   new TEvConfigsDispatcher::TEvGetConfigRequest(kinds, cache)));
     return *runtime.GrabEdgeEventRethrow<TEvConfigsDispatcher::TEvGetConfigResponse>(handle)->Config;
@@ -254,18 +254,18 @@ NKikimrConfig::TAppConfig GetConfig(TTenantTestRuntime &runtime, TVector<ui32> k
 void HoldSubscriber(TTenantTestRuntime &runtime, TActorId aid)
 {
     TAutoPtr<IEventHandle> handle;
-    runtime.Send(new IEventHandle(aid, runtime.Sender, new TEvPrivate::TEvHoldResponse(true)));
+    runtime.Send(new IEventHandleFat(aid, runtime.Sender, new TEvPrivate::TEvHoldResponse(true)));
     runtime.GrabEdgeEventRethrow<TEvPrivate::TEvComplete>(handle);
 }
 
 void UnholdSubscriber(TTenantTestRuntime &runtime, TActorId aid)
 {
-    runtime.Send(new IEventHandle(aid, runtime.Sender, new TEvPrivate::TEvHoldResponse(false)));
+    runtime.Send(new IEventHandleFat(aid, runtime.Sender, new TEvPrivate::TEvHoldResponse(false)));
 }
 
 void SetSubscriptions(TTenantTestRuntime &runtime, TActorId aid, TVector<ui32> kinds)
 {
-    runtime.Send(new IEventHandle(aid, runtime.Sender, new TEvPrivate::TEvSetSubscription(kinds)));
+    runtime.Send(new IEventHandleFat(aid, runtime.Sender, new TEvPrivate::TEvSetSubscription(kinds)));
 }
 
 } // anonymous namespace
diff --git a/ydb/core/cms/console/console.cpp b/ydb/core/cms/console/console.cpp
index e2ed125b40c..47ccec020da 100644
--- a/ydb/core/cms/console/console.cpp
+++ b/ydb/core/cms/console/console.cpp
@@ -59,7 +59,7 @@ void TConsole::Enqueue(TAutoPtr<IEventHandle> &ev, const TActorContext &ctx)
 {
     LOG_DEBUG(ctx, NKikimrServices::CMS,
               "TConsole::Enqueue: %" PRIu64 ", event type: %" PRIu32 " event: %s",
-              TabletID(), ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+              TabletID(), ev->GetTypeRewrite(), ev->ToString().data());
     InitQueue.push_back(ev);
 }
 
@@ -135,7 +135,7 @@ void TConsole::ProcessEnqueuedEvents(const TActorContext &ctx)
         TAutoPtr<IEventHandle> &ev = InitQueue.front();
         LOG_DEBUG(ctx, NKikimrServices::CMS,
                   "TConsole::Dequeue: %" PRIu64 ", event type: %" PRIu32 " event: %s",
-                  TabletID(), ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                  TabletID(), ev->GetTypeRewrite(), ev->ToString().data());
         ctx.ExecutorThread.Send(ev.Release());
         InitQueue.pop_front();
     }
@@ -156,12 +156,12 @@ void TConsole::ClearState()
 
 void TConsole::ForwardToConfigsManager(TAutoPtr<IEventHandle> &ev, const TActorContext &ctx)
 {
-    ctx.Send(ev->Forward(ConfigsManager->SelfId()));
+    ctx.Forward(ev, ConfigsManager->SelfId());
 }
 
 void TConsole::ForwardToTenantsManager(TAutoPtr<IEventHandle> &ev, const TActorContext &ctx)
 {
-    ctx.Send(ev->Forward(TenantsManager->SelfId()));
+    ctx.Forward(ev, TenantsManager->SelfId());
 }
 
 void TConsole::Handle(TEvConsole::TEvGetConfigRequest::TPtr &ev, const TActorContext &ctx)
diff --git a/ydb/core/cms/console/console__add_config_subscription.cpp b/ydb/core/cms/console/console__add_config_subscription.cpp
index 9673df00988..b9165ead987 100644
--- a/ydb/core/cms/console/console__add_config_subscription.cpp
+++ b/ydb/core/cms/console/console__add_config_subscription.cpp
@@ -78,7 +78,7 @@ public:
 
         Y_VERIFY(Response);
         if (!Self->PendingSubscriptionModifications.IsEmpty()) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(Request->Sender,
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(Request->Sender,
                                                          Self->SelfId(),
                                                          Response.Release(), 0,
                                                          Request->Cookie);
diff --git a/ydb/core/cms/console/console__configure.cpp b/ydb/core/cms/console/console__configure.cpp
index 0c720d28427..6760383d85c 100644
--- a/ydb/core/cms/console/console__configure.cpp
+++ b/ydb/core/cms/console/console__configure.cpp
@@ -594,7 +594,7 @@ public:
         Y_VERIFY(Response);
 
         if (!Self->PendingConfigModifications.IsEmpty()) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(Request->Sender,
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(Request->Sender,
                                                          Self->SelfId(),
                                                          Response.Release(), 0,
                                                          Request->Cookie);
diff --git a/ydb/core/cms/console/console__remove_config_subscription.cpp b/ydb/core/cms/console/console__remove_config_subscription.cpp
index e654ec4318a..aba62ca89b6 100644
--- a/ydb/core/cms/console/console__remove_config_subscription.cpp
+++ b/ydb/core/cms/console/console__remove_config_subscription.cpp
@@ -58,7 +58,7 @@ public:
 
         Y_VERIFY(Response);
         if (!Self->PendingSubscriptionModifications.IsEmpty()) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(Request->Sender,
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(Request->Sender,
                                                          Self->SelfId(),
                                                          Response.Release(), 0,
                                                          Request->Cookie);
diff --git a/ydb/core/cms/console/console__remove_config_subscriptions.cpp b/ydb/core/cms/console/console__remove_config_subscriptions.cpp
index e7ec81f811f..f166f1b2d1d 100644
--- a/ydb/core/cms/console/console__remove_config_subscriptions.cpp
+++ b/ydb/core/cms/console/console__remove_config_subscriptions.cpp
@@ -44,7 +44,7 @@ public:
 
         Y_VERIFY(Response);
         if (!Self->PendingSubscriptionModifications.IsEmpty()) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(Request->Sender,
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(Request->Sender,
                                                          Self->SelfId(),
                                                          Response.Release(), 0,
                                                          Request->Cookie);
diff --git a/ydb/core/cms/console/console__replace_config_subscriptions.cpp b/ydb/core/cms/console/console__replace_config_subscriptions.cpp
index 4b75c3a1b52..8a4d8498264 100644
--- a/ydb/core/cms/console/console__replace_config_subscriptions.cpp
+++ b/ydb/core/cms/console/console__replace_config_subscriptions.cpp
@@ -83,7 +83,7 @@ public:
 
         Y_VERIFY(Response);
         if (!Self->PendingSubscriptionModifications.IsEmpty()) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(Request->Sender,
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(Request->Sender,
                                                          Self->SelfId(),
                                                          Response.Release(), 0,
                                                          Request->Cookie);
diff --git a/ydb/core/cms/console/console_configs_manager.cpp b/ydb/core/cms/console/console_configs_manager.cpp
index 20ec44dbdc1..dba0d1b0e48 100644
--- a/ydb/core/cms/console/console_configs_manager.cpp
+++ b/ydb/core/cms/console/console_configs_manager.cpp
@@ -600,7 +600,7 @@ void TConfigsManager::Handle(TEvPrivate::TEvCleanupSubscriptions::TPtr &/*ev*/,
 
 void TConfigsManager::ForwardToConfigsProvider(TAutoPtr<IEventHandle> &ev, const TActorContext &ctx)
 {
-    ctx.Send(ev->Forward(ConfigsProvider));
+    ctx.Forward(ev, ConfigsProvider);
 }
 
 void TConfigsManager::ScheduleSubscriptionsCleanup(const TActorContext &ctx)
@@ -608,7 +608,7 @@ void TConfigsManager::ScheduleSubscriptionsCleanup(const TActorContext &ctx)
     auto *event = new TConfigsManager::TEvPrivate::TEvCleanupSubscriptions;
     SubscriptionsCleanupTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
     CreateLongTimer(ctx, TDuration::Minutes(5),
-                    new IEventHandle(SelfId(), SelfId(), event),
+                    new IEventHandleFat(SelfId(), SelfId(), event),
                     AppData(ctx)->SystemPoolId,
                     SubscriptionsCleanupTimerCookieHolder.Get());
 }
@@ -622,7 +622,7 @@ void TConfigsManager::ScheduleLogCleanup(const TActorContext &ctx)
 {
     LogCleanupTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
     CreateLongTimer(ctx, TDuration::Minutes(15),
-                    new IEventHandle(SelfId(), SelfId(), new TEvPrivate::TEvCleanupLog),
+                    new IEventHandleFat(SelfId(), SelfId(), new TEvPrivate::TEvCleanupLog),
                     AppData(ctx)->SystemPoolId,
                     LogCleanupTimerCookieHolder.Get());
 }
diff --git a/ydb/core/cms/console/console_configs_manager.h b/ydb/core/cms/console/console_configs_manager.h
index f06761c97aa..d79a67d2577 100644
--- a/ydb/core/cms/console/console_configs_manager.h
+++ b/ydb/core/cms/console/console_configs_manager.h
@@ -167,7 +167,7 @@ private:
 
         default:
             Y_FAIL("TConfigsManager::StateWork unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/console/console_configs_provider.cpp b/ydb/core/cms/console/console_configs_provider.cpp
index 84a04981c72..29bd7e2ae19 100644
--- a/ydb/core/cms/console/console_configs_provider.cpp
+++ b/ydb/core/cms/console/console_configs_provider.cpp
@@ -88,7 +88,7 @@ public:
         TimeoutTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
         auto event = new TConfigsProvider::TEvPrivate::TEvNotificationTimeout(Subscription);
         CreateLongTimer(ctx, TDuration::Minutes(10),
-                        new IEventHandle(SelfId(), SelfId(), event),
+                        new IEventHandleFat(SelfId(), SelfId(), event),
                         AppData(ctx)->SystemPoolId,
                         TimeoutTimerCookieHolder.Get());
     }
@@ -141,7 +141,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -210,7 +210,7 @@ public:
         TimeoutTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
         auto event = new TConfigsProvider::TEvPrivate::TEvNotificationTimeout(Subscription);
         CreateLongTimer(ctx, TDuration::Minutes(10),
-                        new IEventHandle(SelfId(), SelfId(), event),
+                        new IEventHandleFat(SelfId(), SelfId(), event),
                         AppData(ctx)->SystemPoolId,
                         TimeoutTimerCookieHolder.Get());
     }
@@ -281,7 +281,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -325,7 +325,7 @@ public:
 
             default:
                 Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                       ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                       ev->GetTypeRewrite(), ev->ToString().data());
                 break;
         }
     }
@@ -1065,8 +1065,8 @@ void TConfigsProvider::Handle(TEvPrivate::TEvUpdateConfigs::TPtr &ev, const TAct
     auto &event = ev->Get()->Event;
     if (event) {
         LOG_TRACE_S(ctx, NKikimrServices::CMS_CONFIGS,
-                    "TConfigsProvider send: " << event->GetBase()->ToString());
-        ctx.Send(event);
+                    "TConfigsProvider send: " << ev->ToString());
+        ctx.Send(event.Release());
     }
 
     ApplyConfigModifications(ev->Get()->Modifications, ctx);
@@ -1077,8 +1077,8 @@ void TConfigsProvider::Handle(TEvPrivate::TEvUpdateSubscriptions::TPtr &ev, cons
     auto &event = ev->Get()->Event;
     if (event) {
         LOG_TRACE_S(ctx, NKikimrServices::CMS_CONFIGS,
-                    "TConfigsProvider send: " << event->GetBase()->ToString());
-        ctx.Send(event);
+                    "TConfigsProvider send: " << ev->ToString());
+        ctx.Send(event.Release());
     }
 
     ApplySubscriptionModifications(ev->Get()->Modifications, ctx);
diff --git a/ydb/core/cms/console/console_configs_provider.h b/ydb/core/cms/console/console_configs_provider.h
index aa2b1192b55..d1c366b694e 100644
--- a/ydb/core/cms/console/console_configs_provider.h
+++ b/ydb/core/cms/console/console_configs_provider.h
@@ -179,7 +179,7 @@ private:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/cms/console/console_configs_subscriber.cpp b/ydb/core/cms/console/console_configs_subscriber.cpp
index 20f3969f86f..bd4592a8def 100644
--- a/ydb/core/cms/console/console_configs_subscriber.cpp
+++ b/ydb/core/cms/console/console_configs_subscriber.cpp
@@ -85,7 +85,7 @@ public:
 
             default:
                 Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                       ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                       ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/console/console_impl.h b/ydb/core/cms/console/console_impl.h
index 62835ca0d42..11a59c2fce6 100644
--- a/ydb/core/cms/console/console_impl.h
+++ b/ydb/core/cms/console/console_impl.h
@@ -120,7 +120,7 @@ private:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_CRIT_S(ctx, NKikimrServices::CMS,
                            "TConsole::StateWork unexpected event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
             }
         }
     }
diff --git a/ydb/core/cms/console/console_tenants_manager.cpp b/ydb/core/cms/console/console_tenants_manager.cpp
index bf6f4e6787c..37cb941d14d 100644
--- a/ydb/core/cms/console/console_tenants_manager.cpp
+++ b/ydb/core/cms/console/console_tenants_manager.cpp
@@ -324,7 +324,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -337,7 +337,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -350,7 +350,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -363,7 +363,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -879,7 +879,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -892,7 +892,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/cms/console/console_tenants_manager.h b/ydb/core/cms/console/console_tenants_manager.h
index 9edf2143714..0932dd273ea 100644
--- a/ydb/core/cms/console/console_tenants_manager.h
+++ b/ydb/core/cms/console/console_tenants_manager.h
@@ -964,7 +964,7 @@ public:
 
         default:
             Y_FAIL("TTenantsManager::StateWork unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/console/console_ut_configs.cpp b/ydb/core/cms/console/console_ut_configs.cpp
index e6bbe48ecbb..9ecdb94e73f 100644
--- a/ydb/core/cms/console/console_ut_configs.cpp
+++ b/ydb/core/cms/console/console_ut_configs.cpp
@@ -565,7 +565,7 @@ void AcceptConfig(TTenantTestRuntime &runtime, TAutoPtr<IEventHandle>& handle)
     auto *response = new TEvConsole::TEvConfigNotificationResponse;
     response->Record.SetSubscriptionId(rec.GetSubscriptionId());
     response->Record.MutableConfigId()->CopyFrom(rec.GetConfigId());
-    runtime.Send(new IEventHandle(handle->Sender, runtime.Sender, response, 0, handle->Cookie));
+    runtime.Send(new IEventHandleFat(handle->Sender, runtime.Sender, response, 0, handle->Cookie));
 }
 
 NKikimrConsole::TConfig GetCurrentConfig(TTenantTestRuntime &runtime)
@@ -3425,12 +3425,12 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
                     ++undelivered;
             }
             if (event->GetTypeRewrite() == TConfigsProvider::TEvPrivate::EvNotificationTimeout
-                && dynamic_cast<TConfigsProvider::TEvPrivate::TEvNotificationTimeout*>(event->GetBase())) {
+                && dynamic_cast<TConfigsProvider::TEvPrivate::TEvNotificationTimeout*>(event->StaticCastAsLocal<IEventBase>())) {
                 attemptFinished = true;
             }
             // Don't allow to cleanup config for missing node.
             if (event->GetTypeRewrite() == TConfigsManager::TEvPrivate::EvCleanupSubscriptions
-                && dynamic_cast<TConfigsManager::TEvPrivate::TEvCleanupSubscriptions*>(event->GetBase()))
+                && dynamic_cast<TConfigsManager::TEvPrivate::TEvCleanupSubscriptions*>(event->StaticCastAsLocal<IEventBase>()))
                 return TTestActorRuntime::EEventAction::DROP;
             return TTestActorRuntime::EEventAction::PROCESS;
         };
@@ -3485,7 +3485,7 @@ Y_UNIT_TEST_SUITE(TConsoleConfigSubscriptionTests) {
         TDispatchOptions options;
         options.FinalEvents.emplace_back([&](IEventHandle &ev) -> bool {
                 if (ev.GetTypeRewrite() == TConfigsManager::TEvPrivate::EvCleanupSubscriptions
-                    && dynamic_cast<TConfigsManager::TEvPrivate::TEvCleanupSubscriptions*>(ev.GetBase()))
+                    && dynamic_cast<TConfigsManager::TEvPrivate::TEvCleanupSubscriptions*>(ev.StaticCastAsLocal<IEventBase>()))
                     return true;
                 return false;
             }, 1);
@@ -3670,7 +3670,7 @@ Y_UNIT_TEST_SUITE(TConsoleInMemoryConfigSubscriptionTests) {
         options1.FinalEvents.emplace_back(TEvConsole::EvConfigSubscriptionResponse, 1);
         runtime.DispatchEvents(options1);
 
-        runtime.Send(new IEventHandle(clientId, edgeId, new TEvents::TEvPoisonPill()), 0, true);
+        runtime.Send(new IEventHandleFat(clientId, edgeId, new TEvents::TEvPoisonPill()), 0, true);
 
         TDispatchOptions options2;
         options2.FinalEvents.emplace_back(TEvConsole::EvConfigSubscriptionCanceled, 3);
@@ -3711,7 +3711,7 @@ Y_UNIT_TEST_SUITE(TConsoleInMemoryConfigSubscriptionTests) {
         UNIT_ASSERT_VALUES_EQUAL(notification1->Get()->Record.GetGeneration(), 1);
         UNIT_ASSERT_VALUES_EQUAL(notification1->Get()->Record.GetConfig().ShortDebugString(), config1.ShortDebugString());
 
-        TAutoPtr<IEventHandle> handle =  new IEventHandle(
+        TAutoPtr<IEventHandle> handle =  new IEventHandleFat(
             runtime.GetInterconnectProxy(0, 1),
             runtime.Sender,
             new TEvInterconnect::TEvDisconnect());
diff --git a/ydb/core/cms/console/console_ut_tenants.cpp b/ydb/core/cms/console/console_ut_tenants.cpp
index 807f8e49667..b0939e102bb 100644
--- a/ydb/core/cms/console/console_ut_tenants.cpp
+++ b/ydb/core/cms/console/console_ut_tenants.cpp
@@ -394,9 +394,9 @@ struct CatchPoolEvent {
     TTenantTestRuntime::EEventAction operator()(TTestActorRuntimeBase&, TAutoPtr<IEventHandle> &ev)
     {
         if (ev->HasEvent()
-            && (dynamic_cast<TTenantsManager::TEvPrivate::TEvPoolAllocated*>(ev->GetBase())
-                || dynamic_cast<TTenantsManager::TEvPrivate::TEvPoolFailed*>(ev->GetBase())
-                || dynamic_cast<TTenantsManager::TEvPrivate::TEvPoolDeleted*>(ev->GetBase()))) {
+            && (ev->Type == TTenantsManager::TEvPrivate::TEvPoolAllocated::EventType)
+                || (ev->Type == TTenantsManager::TEvPrivate::TEvPoolFailed::EventType)
+                || (ev->Type == TTenantsManager::TEvPrivate::TEvPoolDeleted::EventType)) {
             Captured.emplace_back(std::move(ev));
             return TTestActorRuntime::EEventAction::DROP;
         }
@@ -649,7 +649,7 @@ Y_UNIT_TEST_SUITE(TConsoleTxProcessorTests) {
 
 Y_UNIT_TEST_SUITE(TConsoleTests) {
     void RestartTenantPool(TTenantTestRuntime& runtime) {
-        runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(0), 0),
+        runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(0), 0),
                                       runtime.Sender,
                                       new TEvents::TEvPoisonPill));
 
@@ -819,13 +819,13 @@ Y_UNIT_TEST_SUITE(TConsoleTests) {
     }
 
     void RunTestRestartConsoleAndPools(TTenantTestRuntime& runtime) {
-        runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(1), 0),
+        runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(1), 0),
                                       runtime.Sender,
                                       new TEvents::TEvPoisonPill));
-        runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(2), 0),
+        runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(2), 0),
                                       runtime.Sender,
                                       new TEvents::TEvPoisonPill));
-        runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(3), 0),
+        runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(3), 0),
                                       runtime.Sender,
                                       new TEvents::TEvPoisonPill));
 
diff --git a/ydb/core/cms/console/immediate_controls_configurator.cpp b/ydb/core/cms/console/immediate_controls_configurator.cpp
index f3348046f3e..17c55306d1e 100644
--- a/ydb/core/cms/console/immediate_controls_configurator.cpp
+++ b/ydb/core/cms/console/immediate_controls_configurator.cpp
@@ -32,7 +32,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/cms/console/log_settings_configurator.cpp b/ydb/core/cms/console/log_settings_configurator.cpp
index 042f05ee643..11e09e3f30d 100644
--- a/ydb/core/cms/console/log_settings_configurator.cpp
+++ b/ydb/core/cms/console/log_settings_configurator.cpp
@@ -44,7 +44,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -56,7 +56,7 @@ TLogSettingsConfigurator::TLogSettingsConfigurator()
 {
 }
 
-TLogSettingsConfigurator::TLogSettingsConfigurator(const TString &pathToConfigCacheFile) 
+TLogSettingsConfigurator::TLogSettingsConfigurator(const TString &pathToConfigCacheFile)
 {
     PathToConfigCacheFile = pathToConfigCacheFile;
 }
@@ -110,7 +110,7 @@ void TLogSettingsConfigurator::SaveLogSettingsConfigToCache(const NKikimrConfig:
 
         if (!google::protobuf::TextFormat::ParseFromString(cacheFile.ReadAll(), &appConfig))
             ythrow yexception() << "Failed to parse config from cache file " << LastSystemError() << " " << LastSystemErrorText();
-        
+
         appConfig.MutableLogConfig()->CopyFrom(logConfig);
 
         TString proto;
diff --git a/ydb/core/cms/console/net_classifier_updater_ut.cpp b/ydb/core/cms/console/net_classifier_updater_ut.cpp
index 7ebee659f83..b0a80b5eb2b 100644
--- a/ydb/core/cms/console/net_classifier_updater_ut.cpp
+++ b/ydb/core/cms/console/net_classifier_updater_ut.cpp
@@ -148,18 +148,18 @@ Y_UNIT_TEST_SUITE(TNetClassifierUpdaterTest) {
         NActors::TActorId proxyId = actorSystem.Register(proxy);
 
         actorSystem.Send(
-            new NActors::IEventHandle(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(netDataSourcePort)), 0, true
+            new NActors::IEventHandleFat(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(netDataSourcePort)), 0, true
         );
 
         NActors::TActorId serverId = actorSystem.AllocateEdgeActor();
 
-        actorSystem.Send(new NActors::IEventHandle(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler(NETWORKS_URI, serverId)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler(NETWORKS_URI, serverId)), 0, true);
 
         TAutoPtr<NActors::IEventHandle> handle;
         NHttp::TEvHttpProxy::TEvHttpIncomingRequest* request = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingRequest>(handle);
         UNIT_ASSERT_EQUAL(request->Request->URL, NETWORKS_URI);
 
-        actorSystem.Send(new NActors::IEventHandle(handle->Sender, serverId, MakeHttpResponse(request, sourceResponce)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(handle->Sender, serverId, MakeHttpResponse(request, sourceResponce)), 0, true);
         const TActorId sender = actorSystem.AllocateEdgeActor();
 
         size_t iterations = 0;
@@ -168,7 +168,7 @@ Y_UNIT_TEST_SUITE(TNetClassifierUpdaterTest) {
 
             const auto kind = static_cast<ui32>(NKikimrConsole::TConfigItem::NetClassifierDistributableConfigItem);
             actorSystem.Send(
-                new IEventHandle(MakeConfigsDispatcherID(sender.NodeId()), sender,
+                new IEventHandleFat(MakeConfigsDispatcherID(sender.NodeId()), sender,
                     new TEvConfigsDispatcher::TEvGetConfigRequest(kind)
                 ));
 
@@ -201,7 +201,7 @@ Y_UNIT_TEST_SUITE(TNetClassifierUpdaterTest) {
         }
         TestGetUpdatesFromHttpServer(netboxResponce, data, TNetClassifierUpdaterConfig::NETBOX, tags);
     }
-    
+
     void RunNetBoxCommonTests(const TString& netboxResponce) {
         RunNetBoxTest(
             netboxResponce,
@@ -273,7 +273,7 @@ Y_UNIT_TEST_SUITE(TNetClassifierUpdaterTest) {
             }
         );
     }
-    
+
     Y_UNIT_TEST(TestFiltrationByNetboxCustomFieldsAndTags) {
         const TString netboxResponce = R"__(
             {
@@ -289,7 +289,7 @@ Y_UNIT_TEST_SUITE(TNetClassifierUpdaterTest) {
         )__";
         RunTestWithCastomFields(netboxResponce);
     }
-    
+
     Y_UNIT_TEST(TestFiltrationByNetboxCustomFieldsOnly) {
         const TString netboxResponce = R"__(
             {
@@ -303,7 +303,7 @@ Y_UNIT_TEST_SUITE(TNetClassifierUpdaterTest) {
                 ]
             }
         )__";
-        
+
         RunTestWithCastomFields(netboxResponce);
     }
 
diff --git a/ydb/core/cms/console/shared_cache_configurator.cpp b/ydb/core/cms/console/shared_cache_configurator.cpp
index 60f40191c24..55e8d6972dd 100644
--- a/ydb/core/cms/console/shared_cache_configurator.cpp
+++ b/ydb/core/cms/console/shared_cache_configurator.cpp
@@ -72,7 +72,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/cms/console/ut_helpers.h b/ydb/core/cms/console/ut_helpers.h
index 5786a8b89e6..d6cc62c9015 100644
--- a/ydb/core/cms/console/ut_helpers.h
+++ b/ydb/core/cms/console/ut_helpers.h
@@ -238,7 +238,7 @@ inline void ChangeTenant(TTenantTestRuntime &runtime,
                          ui32 nodeIdx = 0,
                          bool wait = true)
 {
-    runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(nodeIdx)),
+    runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(nodeIdx)),
                                   runtime.Sender,
                                   new TEvTenantPool::TEvTakeOwnership));
 
@@ -249,7 +249,7 @@ inline void ChangeTenant(TTenantTestRuntime &runtime,
     request->Record.SetSlotId("slot");
     request->Record.SetAssignedTenant(tenant);
     request->Record.SetLabel("slot-1");
-    runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(nodeIdx)),
+    runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(nodeIdx)),
                                   runtime.Sender,
                                   request));
 
diff --git a/ydb/core/cms/info_collector.cpp b/ydb/core/cms/info_collector.cpp
index 55fc07e1384..14e3fce7572 100644
--- a/ydb/core/cms/info_collector.cpp
+++ b/ydb/core/cms/info_collector.cpp
@@ -73,7 +73,7 @@ private:
         default:
             LOG_E("Unexpected event"
                 << ": type# " << ev->GetTypeRewrite()
-                << ", event# " << (ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                << ", event# " << ev->ToString());
         }
     }
 
@@ -83,11 +83,11 @@ private:
 
     // Nodes
     void Handle(TEvInterconnect::TEvNodesInfo::TPtr& ev);
-    
+
     //Configs
     void RequestBootstrapConfig();
     void Handle(TEvConfigsDispatcher::TEvGetConfigResponse::TPtr &ev);
-    
+
     // State Storage
     void RequestStateStorageConfig();
     void Handle(TEvStateStorage::TEvListStateStorageResult::TPtr &ev);
@@ -129,7 +129,7 @@ private:
 
 void TInfoCollector::ReplyAndDie() {
     auto ev = MakeHolder<TCms::TEvPrivate::TEvClusterInfo>();
-    ev->Success = BaseConfigReceived 
+    ev->Success = BaseConfigReceived
                   && BootstrapConfigReceived
                   && StateStorageInfoReceived;
 
@@ -155,7 +155,7 @@ void TInfoCollector::ReplyAndDie() {
 }
 
 void TInfoCollector::MaybeReplyAndDie() {
-    if (!BaseConfigReceived 
+    if (!BaseConfigReceived
         || !BootstrapConfigReceived
         || !StateStorageInfoReceived) {
         return;
@@ -212,7 +212,7 @@ void TInfoCollector::Handle(TEvConfigsDispatcher::TEvGetConfigResponse::TPtr &ev
     BootstrapConfigReceived = true;
     if (!config->HasBootstrapConfig()){
         LOG_I("Couldn't collect bootstrap config from Console. Taking the local config");
-        bootstrap.CopyFrom(AppData()->BootstrapConfig); 
+        bootstrap.CopyFrom(AppData()->BootstrapConfig);
     } else {
         LOG_D("Got Bootstrap config"
               << ": record# " <<  config->ShortDebugString());
diff --git a/ydb/core/cms/json_proxy.h b/ydb/core/cms/json_proxy.h
index 3611c2d7281..a0c6e5dbb10 100644
--- a/ydb/core/cms/json_proxy.h
+++ b/ydb/core/cms/json_proxy.h
@@ -96,7 +96,7 @@ protected:
             HFunc(TEvTabletPipe::TEvClientConnected, Handle);
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS, "HTTP::StateWork ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/sentinel_ut.cpp b/ydb/core/cms/sentinel_ut.cpp
index 05410b5a90c..2e7d87bd4fd 100644
--- a/ydb/core/cms/sentinel_ut.cpp
+++ b/ydb/core/cms/sentinel_ut.cpp
@@ -363,7 +363,7 @@ Y_UNIT_TEST_SUITE(TSentinelTests) {
                 pdisk.SetState(state);
             }
 
-            Send(new IEventHandle(Sentinel, TActorId(), new TEvSentinel::TEvUpdateState));
+            Send(new IEventHandleFat(Sentinel, TActorId(), new TEvSentinel::TEvUpdateState));
         }
 
     public:
@@ -398,7 +398,7 @@ Y_UNIT_TEST_SUITE(TSentinelTests) {
                             NCms::TCms::AddHostState(State->ClusterInfo, *entry.second, resp->Record, State->ClusterInfo->GetTimestamp());
                         }
                     }
-                    Send(new IEventHandle(event->Sender, TActorId(), resp.Release()));
+                    Send(new IEventHandleFat(event->Sender, TActorId(), resp.Release()));
                     return TTestActorRuntime::EEventAction::PROCESS;
                 }
                 default:
diff --git a/ydb/core/cms/walle_api_handler.cpp b/ydb/core/cms/walle_api_handler.cpp
index 953a560b110..c11eeabb2a8 100644
--- a/ydb/core/cms/walle_api_handler.cpp
+++ b/ydb/core/cms/walle_api_handler.cpp
@@ -101,7 +101,7 @@ private:
             CFunc(TEvents::TSystem::Wakeup, Timeout);
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS, "TWalleApiHandler::StateCreateTask ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
@@ -148,7 +148,7 @@ private:
             CFunc(TEvents::TSystem::Wakeup, Timeout);
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS, "TWalleApiHandler::StateListTasks ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
@@ -199,7 +199,7 @@ private:
             CFunc(TEvents::TSystem::Wakeup, Timeout);
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS, "TWalleApiHandler::StateCheckTask ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
@@ -247,7 +247,7 @@ private:
             CFunc(TEvents::TSystem::Wakeup, Timeout);
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS, "TWalleApiHandler::StateRemoveTask ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/walle_check_task_adapter.cpp b/ydb/core/cms/walle_check_task_adapter.cpp
index 465c371d0d3..187924d8b42 100644
--- a/ydb/core/cms/walle_check_task_adapter.cpp
+++ b/ydb/core/cms/walle_check_task_adapter.cpp
@@ -78,7 +78,7 @@ private:
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS,
                       "TWalleRemoveTaskAdapter::StateWork ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/cms/walle_create_task_adapter.cpp b/ydb/core/cms/walle_create_task_adapter.cpp
index 46fc55d9860..3eb92fe521a 100644
--- a/ydb/core/cms/walle_create_task_adapter.cpp
+++ b/ydb/core/cms/walle_create_task_adapter.cpp
@@ -66,7 +66,7 @@ private:
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS,
                       "TWalleCreateTaskAdapter::StateWork ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
@@ -204,7 +204,7 @@ private:
         ctx.Send(Cms, request.Release());
     }
 
-    void Handle(TEvCms::TEvStoreWalleTaskFailed::TPtr &ev, const TActorContext &ctx) { 
+    void Handle(TEvCms::TEvStoreWalleTaskFailed::TPtr &ev, const TActorContext &ctx) {
         ReplyWithErrorAndDie(TStatus::ERROR_TEMP, ev.Get()->Get()->Reason, ctx);
     }
 
diff --git a/ydb/core/cms/walle_remove_task_adapter.cpp b/ydb/core/cms/walle_remove_task_adapter.cpp
index 5cd79426386..f25fdeac411 100644
--- a/ydb/core/cms/walle_remove_task_adapter.cpp
+++ b/ydb/core/cms/walle_remove_task_adapter.cpp
@@ -49,7 +49,7 @@ private:
         default:
             LOG_DEBUG(ctx, NKikimrServices::CMS,
                       "TWalleRemoveTaskAdapter::StateWork ignored event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/discovery/discovery.cpp b/ydb/core/discovery/discovery.cpp
index d513f2a3b38..717f68d5c9f 100644
--- a/ydb/core/discovery/discovery.cpp
+++ b/ydb/core/discovery/discovery.cpp
@@ -204,7 +204,7 @@ public:
     }
 
     void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev) {
-        SchemeCacheResponse.Reset(ev->Release().Release());
+        SchemeCacheResponse.Reset(ev.Release());
 
         const auto* response = SchemeCacheResponse.Get()->Request.Get();
 
diff --git a/ydb/core/driver_lib/run/run.cpp b/ydb/core/driver_lib/run/run.cpp
index 79854340b1f..086884fc92c 100644
--- a/ydb/core/driver_lib/run/run.cpp
+++ b/ydb/core/driver_lib/run/run.cpp
@@ -1616,13 +1616,13 @@ void TKikimrRunner::KikimrStop(bool graceful) {
     Y_UNUSED(graceful);
 
     if (EnabledGrpcService) {
-        ActorSystem->Send(new IEventHandle(NGRpcService::CreateGrpcPublisherServiceActorId(), {}, new TEvents::TEvPoisonPill));
+        ActorSystem->Send(new IEventHandleFat(NGRpcService::CreateGrpcPublisherServiceActorId(), {}, new TEvents::TEvPoisonPill));
     }
 
     TIntrusivePtr<TDrainProgress> drainProgress(new TDrainProgress());
     if (AppData->FeatureFlags.GetEnableDrainOnShutdown() && GracefulShutdownSupported && ActorSystem) {
         drainProgress->OnSend();
-        ActorSystem->Send(new IEventHandle(MakeTenantPoolRootID(), {}, new TEvLocal::TEvLocalDrainNode(drainProgress)));
+        ActorSystem->Send(new IEventHandleFat(MakeTenantPoolRootID(), {}, new TEvLocal::TEvLocalDrainNode(drainProgress)));
     }
 
     if (KqpShutdownController) {
@@ -1654,10 +1654,10 @@ void TKikimrRunner::KikimrStop(bool graceful) {
 
     if (ActorSystem) {
         ActorSystem->BroadcastToProxies([](const TActorId& proxyId) {
-            return new IEventHandle(proxyId, {}, new TEvInterconnect::TEvTerminate);
+            return new IEventHandleFat(proxyId, {}, new TEvInterconnect::TEvTerminate);
         });
-        ActorSystem->Send(new IEventHandle(MakeInterconnectListenerActorId(false), {}, new TEvents::TEvPoisonPill));
-        ActorSystem->Send(new IEventHandle(MakeInterconnectListenerActorId(true), {}, new TEvents::TEvPoisonPill));
+        ActorSystem->Send(new IEventHandleFat(MakeInterconnectListenerActorId(false), {}, new TEvents::TEvPoisonPill));
+        ActorSystem->Send(new IEventHandleFat(MakeInterconnectListenerActorId(true), {}, new TEvents::TEvPoisonPill));
     }
 
     if (SqsHttp) {
diff --git a/ydb/core/grpc_services/grpc_request_check_actor.h b/ydb/core/grpc_services/grpc_request_check_actor.h
index 8db80367fc0..1efbce9477e 100644
--- a/ydb/core/grpc_services/grpc_request_check_actor.h
+++ b/ydb/core/grpc_services/grpc_request_check_actor.h
@@ -79,7 +79,7 @@ public:
         const TActorId& owner,
         const TSchemeBoardEvents::TDescribeSchemeResult& schemeData,
         TIntrusivePtr<TSecurityObject> securityObject,
-        TAutoPtr<TEventHandle<TEvent>> request,
+        TAutoPtr<TEventHandleFat<TEvent>> request,
         IGRpcProxyCounters::TPtr counters,
         bool skipCheckConnectRigths,
         const IFacilityProvider* facilityProvider)
@@ -386,12 +386,12 @@ private:
         HandleAndDie(Request_);
     }
 
-    void HandleAndDie(TAutoPtr<TEventHandle<TEvProxyRuntimeEvent>>& event) {
+    void HandleAndDie(TAutoPtr<TEventHandleFat<TEvProxyRuntimeEvent>>& event) {
         event->Release().Release()->Pass(*this);
         TBase::PassAway();
     }
 
-    void HandleAndDie(TAutoPtr<TEventHandle<TEvListEndpointsRequest>>&) {
+    void HandleAndDie(TAutoPtr<TEventHandleFat<TEvListEndpointsRequest>>&) {
         ReplyBackAndDie();
     }
 
@@ -473,7 +473,7 @@ private:
     }
 
     const TActorId Owner_;
-    TAutoPtr<TEventHandle<TEvent>> Request_;
+    TAutoPtr<TEventHandleFat<TEvent>> Request_;
     IGRpcProxyCounters::TPtr Counters_;
     TIntrusivePtr<TSecurityObject> SecurityObject_;
     TString CheckedDatabaseName_;
@@ -509,7 +509,7 @@ IActor* CreateGrpcRequestCheckActor(
     const TActorId& owner,
     const TSchemeBoardEvents::TDescribeSchemeResult& schemeData,
     TIntrusivePtr<TSecurityObject> securityObject,
-    TAutoPtr<TEventHandle<TEvent>> request,
+    TAutoPtr<TEventHandleFat<TEvent>> request,
     IGRpcProxyCounters::TPtr counters,
     bool skipCheckConnectRigths,
     const IFacilityProvider* facilityProvider) {
diff --git a/ydb/core/grpc_services/grpc_request_proxy.cpp b/ydb/core/grpc_services/grpc_request_proxy.cpp
index 297a922b5be..26ea861b506 100644
--- a/ydb/core/grpc_services/grpc_request_proxy.cpp
+++ b/ydb/core/grpc_services/grpc_request_proxy.cpp
@@ -82,7 +82,7 @@ private:
     static bool IsAuthStateOK(const IRequestProxyCtx& ctx);
 
     template <typename TEvent>
-    void Handle(TAutoPtr<TEventHandle<TEvent>>& event, const TActorContext& ctx) {
+    void Handle(TAutoPtr<TEventHandleFat<TEvent>>& event, const TActorContext& ctx) {
         IRequestProxyCtx* requestBaseCtx = event->Get();
         if (ValidateAndReplyOnError(requestBaseCtx)) {
             TGRpcRequestProxyHandleMethods::Handle(event, ctx);
@@ -115,7 +115,7 @@ private:
     // returns true and defer event if no updates for given database
     // otherwice returns false and leave event untouched
     template <typename TEvent>
-    bool DeferAndStartUpdate(const TString& database, TAutoPtr<TEventHandle<TEvent>>& ev, IRequestProxyCtx* reqCtx) {
+    bool DeferAndStartUpdate(const TString& database, TAutoPtr<TEventHandleFat<TEvent>>& ev, IRequestProxyCtx* reqCtx) {
         std::deque<TEventReqHolder>& queue = DeferredEvents[database];
         if (queue.size() >= MAX_DEFERRED_EVENTS_PER_DATABASE) {
             return false;
@@ -130,7 +130,7 @@ private:
     }
 
     template <typename TEvent>
-    void PreHandle(TAutoPtr<TEventHandle<TEvent>>& event, const TActorContext& ctx) {
+    void PreHandle(TAutoPtr<TEventHandleFat<TEvent>>& event, const TActorContext& ctx) {
         IRequestProxyCtx* requestBaseCtx = event->Get();
 
         LogRequest(event);
diff --git a/ydb/core/grpc_services/grpc_request_proxy_simple.cpp b/ydb/core/grpc_services/grpc_request_proxy_simple.cpp
index 881251da18c..4034cfc4d4a 100644
--- a/ydb/core/grpc_services/grpc_request_proxy_simple.cpp
+++ b/ydb/core/grpc_services/grpc_request_proxy_simple.cpp
@@ -97,7 +97,7 @@ private:
     }
 
     template <typename TEvent>
-    void PreHandle(TAutoPtr<TEventHandle<TEvent>>& event, const TActorContext& ctx) {
+    void PreHandle(TAutoPtr<TEventHandleFat<TEvent>>& event, const TActorContext& ctx) {
         IRequestProxyCtx* requestBaseCtx = event->Get();
 
         LogRequest(event);
diff --git a/ydb/core/grpc_services/operation_helpers.cpp b/ydb/core/grpc_services/operation_helpers.cpp
index aafa99bc2c2..c66b6be2d9b 100644
--- a/ydb/core/grpc_services/operation_helpers.cpp
+++ b/ydb/core/grpc_services/operation_helpers.cpp
@@ -31,7 +31,7 @@ using std::shared_ptr;
 #define LOG_W(stream) LOG_WARN_S(*TlsActivationContext, NKikimrServices::TX_PROXY, LogPrefix << stream)
 #define LOG_E(stream) LOG_ERROR_S(*TlsActivationContext, NKikimrServices::TX_PROXY, LogPrefix << stream)
 
-IEventBase* CreateNavigateForPath(const TString& path) {
+IEventHandleLight* CreateNavigateForPath(const TString& path) {
     auto request = MakeHolder<NSchemeCache::TSchemeCacheNavigate>();
 
     request->DatabaseName = path;
diff --git a/ydb/core/grpc_services/operation_helpers.h b/ydb/core/grpc_services/operation_helpers.h
index 845b635a963..a3296d0f4cd 100644
--- a/ydb/core/grpc_services/operation_helpers.h
+++ b/ydb/core/grpc_services/operation_helpers.h
@@ -18,7 +18,7 @@ namespace NGRpcService {
 
 class IRequestOpCtx;
 
-IEventBase* CreateNavigateForPath(const TString& path);
+IEventHandleLight* CreateNavigateForPath(const TString& path);
 TActorId CreatePipeClient(ui64 id, const TActorContext& ctx);
 Ydb::TOperationId ToOperationId(const NKikimrIndexBuilder::TIndexBuild& build);
 void ToOperation(const NKikimrIndexBuilder::TIndexBuild& build, Ydb::Operations::Operation* operation);
diff --git a/ydb/core/grpc_services/query/rpc_execute_query.cpp b/ydb/core/grpc_services/query/rpc_execute_query.cpp
index 559b84c977a..20d46acb8a1 100644
--- a/ydb/core/grpc_services/query/rpc_execute_query.cpp
+++ b/ydb/core/grpc_services/query/rpc_execute_query.cpp
@@ -263,7 +263,7 @@ private:
 
     void UnexpectedEvent(const TString& state, TAutoPtr<NActors::IEventHandle>& ev, const TActorContext& ctx) {
         InternalError(TStringBuilder() << "TExecuteQueryRPC in state " << state << " received unexpected event " <<
-            TypeName(*ev.Get()->GetBase()) << Sprintf("(0x%08" PRIx32 ")", ev->GetTypeRewrite()), ctx);
+            ev->GetTypeName() << Sprintf("(0x%08" PRIx32 ")", ev->GetTypeRewrite()), ctx);
     }
 
 private:
diff --git a/ydb/core/grpc_services/rpc_calls.cpp b/ydb/core/grpc_services/rpc_calls.cpp
index 0bb41f28b60..b1133439c8f 100644
--- a/ydb/core/grpc_services/rpc_calls.cpp
+++ b/ydb/core/grpc_services/rpc_calls.cpp
@@ -74,7 +74,7 @@ void RefreshToken(const TString& token, const TString& database, const TActorCon
 }
 
 void TRefreshTokenImpl::ReplyUnauthenticated(const TString&) {
-    TActivationContext::Send(new IEventHandle(From_, TActorId(),
+    TActivationContext::Send(new IEventHandleFat(From_, TActorId(),
         new TGRpcRequestProxy::TEvRefreshTokenResponse
             { false, nullptr, false, IssueManager_.GetIssues()}));
 }
diff --git a/ydb/core/grpc_services/rpc_deferrable.h b/ydb/core/grpc_services/rpc_deferrable.h
index aa3130434f1..1ed92a37c47 100644
--- a/ydb/core/grpc_services/rpc_deferrable.h
+++ b/ydb/core/grpc_services/rpc_deferrable.h
@@ -62,13 +62,13 @@ public:
 
         if (OperationTimeout_) {
             OperationTimeoutTimer = CreateLongTimer(ctx, OperationTimeout_,
-                new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(WakeupTagTimeout)),
+                new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(WakeupTagTimeout)),
                 AppData(ctx)->UserPoolId);
         }
 
         if (HasCancel_ && CancelAfter_) {
             CancelAfterTimer = CreateLongTimer(ctx, CancelAfter_,
-                new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(WakeupTagCancel)),
+                new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(WakeupTagCancel)),
                 AppData(ctx)->UserPoolId);
         }
 
diff --git a/ydb/core/grpc_services/rpc_kh_describe.cpp b/ydb/core/grpc_services/rpc_kh_describe.cpp
index 4f2c59582a0..906593e62c8 100644
--- a/ydb/core/grpc_services/rpc_kh_describe.cpp
+++ b/ydb/core/grpc_services/rpc_kh_describe.cpp
@@ -113,7 +113,7 @@ private:
             ctx.Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvNavigateKeySet(request));
 
             TimeoutTimerActorId = CreateLongTimer(ctx, Timeout,
-                new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
+                new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
 
             TBase::Become(&TThis::StateWaitResolveTable);
             WaitingResolveReply = true;
diff --git a/ydb/core/grpc_services/rpc_long_tx.cpp b/ydb/core/grpc_services/rpc_long_tx.cpp
index be07f4066df..8b8eb20a369 100644
--- a/ydb/core/grpc_services/rpc_long_tx.cpp
+++ b/ydb/core/grpc_services/rpc_long_tx.cpp
@@ -518,7 +518,7 @@ private:
             if (delayed) {
                 if (ShardsToRetry.empty()) {
                     TimeoutTimerActorId = CreateLongTimer(TRetryData::OverloadTimeout(),
-                        new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup()));
+                        new IEventHandleFat(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup()));
                 }
                 ShardsToRetry.insert(shardId);
             } else {
diff --git a/ydb/core/grpc_services/rpc_read_columns.cpp b/ydb/core/grpc_services/rpc_read_columns.cpp
index 5f17fd72f08..73bb2ba7366 100644
--- a/ydb/core/grpc_services/rpc_read_columns.cpp
+++ b/ydb/core/grpc_services/rpc_read_columns.cpp
@@ -163,7 +163,7 @@ private:
             ctx.Send(SchemeCache, new TEvTxProxySchemeCache::TEvNavigateKeySet(request));
 
             TimeoutTimerActorId = CreateLongTimer(ctx, Timeout,
-                new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
+                new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
 
             TBase::Become(&TThis::StateWaitResolveTable);
             WaitingResolveReply = true;
diff --git a/ydb/core/grpc_services/rpc_read_table.cpp b/ydb/core/grpc_services/rpc_read_table.cpp
index e4a68edbbf9..b344fd1ba14 100644
--- a/ydb/core/grpc_services/rpc_read_table.cpp
+++ b/ydb/core/grpc_services/rpc_read_table.cpp
@@ -581,7 +581,7 @@ private:
             timer = {};
         }
 
-        auto *ev = new IEventHandle(SelfId(), SelfId(), new TEvents::TEvWakeup(tag));
+        auto *ev = new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvWakeup(tag));
         timer = CreateLongTimer(timeout, ev);
     }
 
diff --git a/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp b/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp
index a1e312c253c..1f5de54a17a 100644
--- a/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp
+++ b/ydb/core/grpc_services/rpc_stream_execute_scan_query.cpp
@@ -398,7 +398,7 @@ private:
     void SetTimeoutTimer(TDuration timeout, const TActorContext& ctx) {
         LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Set stream timeout timer for " << timeout);
 
-        auto *ev = new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup(EWakeupTag::TimeoutTag));
+        auto *ev = new IEventHandleFat(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup(EWakeupTag::TimeoutTag));
         TimeoutTimerCookieHolder_.Reset(ISchedulerCookie::Make2Way());
         CreateLongTimer(ctx, timeout, ev, 0, TimeoutTimerCookieHolder_.Get());
     }
diff --git a/ydb/core/grpc_services/rpc_stream_execute_yql_script.cpp b/ydb/core/grpc_services/rpc_stream_execute_yql_script.cpp
index d3cef938923..b66818fbb9e 100644
--- a/ydb/core/grpc_services/rpc_stream_execute_yql_script.cpp
+++ b/ydb/core/grpc_services/rpc_stream_execute_yql_script.cpp
@@ -358,7 +358,7 @@ private:
     void SetClientTimeoutTimer(TDuration timeout, const TActorContext& ctx) {
         LOG_DEBUG_S(ctx, NKikimrServices::RPC_REQUEST, this->SelfId() << " Set stream timeout timer for " << timeout);
 
-        auto *ev = new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup(EStreamRpcWakeupTag::ClientTimeoutTag));
+        auto *ev = new IEventHandleFat(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup(EStreamRpcWakeupTag::ClientTimeoutTag));
         ClientTimeoutTimerCookieHolder_.Reset(ISchedulerCookie::Make2Way());
         CreateLongTimer(ctx, timeout, ev, 0, ClientTimeoutTimerCookieHolder_.Get());
     }
diff --git a/ydb/core/health_check/health_check_ut.cpp b/ydb/core/health_check/health_check_ut.cpp
index b402d39f2d1..49dc17b8e97 100644
--- a/ydb/core/health_check/health_check_ut.cpp
+++ b/ydb/core/health_check/health_check_ut.cpp
@@ -32,7 +32,7 @@ Y_UNIT_TEST_SUITE(THealthCheckTest) {
         TActorId sender = runtime->AllocateEdgeActor();
         TAutoPtr<IEventHandle> handle;
 
-        runtime->Send(new IEventHandle(NHealthCheck::MakeHealthCheckID(), sender, ev, 0));
+        runtime->Send(new IEventHandleFat(NHealthCheck::MakeHealthCheckID(), sender, ev, 0));
         NHealthCheck::TEvSelfCheckResult* result = runtime->GrabEdgeEvent<NHealthCheck::TEvSelfCheckResult>(handle);
 
         UNIT_ASSERT(result != nullptr);
@@ -48,7 +48,7 @@ Y_UNIT_TEST_SUITE(THealthCheckTest) {
 
     int const GROUP_START_ID = 1200;
     int const VCARD_START_ID = 5500;
-    
+
     void ChangeDescribeSchemeResult(TEvSchemeShard::TEvDescribeSchemeResult::TPtr* ev, ui64 size = 20000000, ui64 quota = 90000000) {
         auto record = (*ev)->Get()->MutableRecord();
         auto pool = record->mutable_pathdescription()->mutable_domaindescription()->add_storagepools();
@@ -173,13 +173,13 @@ Y_UNIT_TEST_SUITE(THealthCheckTest) {
                     break;
                 }
             }
-            
+
             return TTestActorRuntime::EEventAction::PROCESS;
         };
         runtime.SetObserverFunc(observerFunc);
 
         auto *request = new NHealthCheck::TEvSelfCheckRequest;
-        runtime.Send(new IEventHandle(NHealthCheck::MakeHealthCheckID(), sender, request, 0));
+        runtime.Send(new IEventHandleFat(NHealthCheck::MakeHealthCheckID(), sender, request, 0));
         NHealthCheck::TEvSelfCheckResult* result = runtime.GrabEdgeEvent<NHealthCheck::TEvSelfCheckResult>(handle);
 
         int groupIssuesCount = 0;
@@ -293,15 +293,15 @@ Y_UNIT_TEST_SUITE(THealthCheckTest) {
                     break;
                 }
             }
-            
+
             return TTestActorRuntime::EEventAction::PROCESS;
         };
         runtime.SetObserverFunc(observerFunc);
 
         auto *request = new NHealthCheck::TEvSelfCheckRequest;
-        runtime.Send(new IEventHandle(NHealthCheck::MakeHealthCheckID(), sender, request, 0));
+        runtime.Send(new IEventHandleFat(NHealthCheck::MakeHealthCheckID(), sender, request, 0));
         NHealthCheck::TEvSelfCheckResult* result = runtime.GrabEdgeEvent<NHealthCheck::TEvSelfCheckResult>(handle);
-        
+
         int storageIssuesCount = 0;
         for (const auto& issue_log : result->Result.Getissue_log()) {
             if (issue_log.type() == "STORAGE" && issue_log.reason_size() == 0 && issue_log.status() == status) {
diff --git a/ydb/core/http_proxy/http_service.cpp b/ydb/core/http_proxy/http_service.cpp
index a08d764bc55..4bfbb53c2c6 100644
--- a/ydb/core/http_proxy/http_service.cpp
+++ b/ydb/core/http_proxy/http_service.cpp
@@ -70,7 +70,7 @@ namespace NKikimr::NHttpProxy {
         ev->CertificateFile = config.GetCert();
         ev->PrivateKeyFile = config.GetKey();
 
-        ctx.Send(new NActors::IEventHandle(MakeHttpServerServiceID(), TActorId(),
+        ctx.Send(new NActors::IEventHandleFat(MakeHttpServerServiceID(), TActorId(),
                                            ev.Release(), 0, true));
         ctx.Send(MakeHttpServerServiceID(),
                  new NHttp::TEvHttpProxy::TEvRegisterHandler("/", MakeHttpProxyID()));
diff --git a/ydb/core/kesus/proxy/proxy.cpp b/ydb/core/kesus/proxy/proxy.cpp
index 9633816e60a..8c14840a14c 100644
--- a/ydb/core/kesus/proxy/proxy.cpp
+++ b/ydb/core/kesus/proxy/proxy.cpp
@@ -249,7 +249,7 @@ private:
         const auto& ctx = TActivationContext::AsActorContext();
         LOG_TRACE_S(ctx, NKikimrServices::KESUS_PROXY,
             "Forwarding resolve result from SchemeCache: " << KesusPath.Quote());
-        Send(Owner, new TEvPrivate::TEvResolveResult(KesusPath, THolder<TEvTxProxySchemeCache::TEvNavigateKeySetResult>(ev->Release().Release())));
+        Send(Owner, new TEvPrivate::TEvResolveResult(KesusPath, THolder<TEvTxProxySchemeCache::TEvNavigateKeySetResult>(ev.Release())));
         PassAway();
     }
 
diff --git a/ydb/core/kesus/proxy/ut_helpers.cpp b/ydb/core/kesus/proxy/ut_helpers.cpp
index 0e984c380d9..f35b1e1525b 100644
--- a/ydb/core/kesus/proxy/ut_helpers.cpp
+++ b/ydb/core/kesus/proxy/ut_helpers.cpp
@@ -42,7 +42,7 @@ void TTestContext::SetupTabletServices() {
 
 void TTestContext::Sleep(ui64 millis) {
     TActorId sender = Runtime->AllocateEdgeActor();
-    Runtime->Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), TDuration::MilliSeconds(millis), 0);
+    Runtime->Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), TDuration::MilliSeconds(millis), 0);
     ExpectEdgeEvent<TEvents::TEvWakeup>(sender, 0);
 }
 
@@ -71,7 +71,7 @@ TActorId TTestContext::GetProxy(ui64 proxyId, ui32 nodeIndex) {
 void TTestContext::SendFromEdge(ui64 proxyId, const TActorId& edge, IEventBase* payload, ui64 cookie) {
     ui32 nodeIndex = edge.NodeId() - Runtime->GetNodeId(0);
     Runtime->Send(
-        new IEventHandle(GetProxy(proxyId), edge, payload, 0, cookie),
+        new IEventHandleFat(GetProxy(proxyId), edge, payload, 0, cookie),
         nodeIndex,
         true);
 }
diff --git a/ydb/core/kesus/tablet/rate_accounting.cpp b/ydb/core/kesus/tablet/rate_accounting.cpp
index 7b451232af4..acc3b5f6d69 100644
--- a/ydb/core/kesus/tablet/rate_accounting.cpp
+++ b/ydb/core/kesus/tablet/rate_accounting.cpp
@@ -332,7 +332,7 @@ TRateAccounting::TRateAccounting(NActors::TActorId kesus, const IBillSink::TPtr&
 }
 
 void TRateAccounting::Stop() {
-    TActivationContext::Send(new IEventHandle(AccountingActor, Kesus,
+    TActivationContext::Send(new IEventHandleFat(AccountingActor, Kesus,
         new TEvents::TEvPoisonPill()));
 }
 
@@ -374,7 +374,7 @@ void TRateAccounting::Configure(const NKikimrKesus::TStreamingQuoterResource& pr
     // NOTE: Configure is called with effective props
     Props = props;
     ConfigureImpl();
-    TActivationContext::Send(new NActors::IEventHandle(AccountingActor, Kesus,
+    TActivationContext::Send(new NActors::IEventHandleFat(AccountingActor, Kesus,
         new TEvPrivate::TEvConfigure(TActivationContext::Now(), props)));
 }
 
@@ -452,7 +452,7 @@ bool TRateAccounting::RunAccounting() {
 
 void TRateAccounting::SetResourceCounters(const TIntrusivePtr<::NMonitoring::TDynamicCounters>& resourceCounters) {
     Counters.SetResourceCounters(resourceCounters);
-    TActivationContext::Send(new NActors::IEventHandle(AccountingActor, Kesus,
+    TActivationContext::Send(new NActors::IEventHandleFat(AccountingActor, Kesus,
         new TEvPrivate::TEvCounters(Counters)));
 }
 
@@ -471,7 +471,7 @@ bool TRateAccounting::RunAccountingNoClean() {
     }
 
     // Offload hard work into accounting actor
-    TActivationContext::Send(new NActors::IEventHandle(AccountingActor, Kesus,
+    TActivationContext::Send(new NActors::IEventHandleFat(AccountingActor, Kesus,
         new TEvPrivate::TEvRunAccounting(
             accountTill - History.Interval(),
             TConsumptionHistory(History, Accounted, accountTill))));
diff --git a/ydb/core/kesus/tablet/tablet_ut.cpp b/ydb/core/kesus/tablet/tablet_ut.cpp
index d73b3c38053..fb24b20789d 100644
--- a/ydb/core/kesus/tablet/tablet_ut.cpp
+++ b/ydb/core/kesus/tablet/tablet_ut.cpp
@@ -121,7 +121,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         // drop link between 2 nodes
         {
             ctx.Runtime->Send(
-                new IEventHandle(
+                new IEventHandleFat(
                     ctx.Runtime->GetInterconnectProxy(0, 1),
                     TActorId(),
                     new TEvInterconnect::TEvDisconnect()),
@@ -2266,7 +2266,7 @@ Y_UNIT_TEST_SUITE(TKesusTest) {
         WaitAllocation(edgeAndSession2.first, 5);
 
         // Kill pipe and then session must be deactivated on kesus.
-        ctx.Runtime->Send(new IEventHandle(edgeAndSession2.second, edgeAndSession2.first, new TEvents::TEvPoisonPill()));
+        ctx.Runtime->Send(new IEventHandleFat(edgeAndSession2.second, edgeAndSession2.first, new TEvents::TEvPoisonPill()));
         WaitAllocation(edgeAndSession1.first, 10); // Now first session is the only active session and it receives all resource.
     }
 }
diff --git a/ydb/core/kesus/tablet/tx_self_check.cpp b/ydb/core/kesus/tablet/tx_self_check.cpp
index cb2c83b0e06..a15d89e4e72 100644
--- a/ydb/core/kesus/tablet/tx_self_check.cpp
+++ b/ydb/core/kesus/tablet/tx_self_check.cpp
@@ -45,7 +45,7 @@ bool TKesusTablet::ScheduleSelfCheck(const TActorContext& ctx) {
     TDuration sessionGraceTimeout = Max(Min(SessionGracePeriod, MAX_SESSION_GRACE_PERIOD), selfCheckPeriod + MIN_SESSION_GRACE_PERIOD);
     TInstant deadline = ctx.Now() + sessionGraceTimeout;
     CreateLongTimer(ctx, selfCheckPeriod,
-        new IEventHandle(SelfId(), SelfId(),
+        new IEventHandleFat(SelfId(), SelfId(),
             new TEvPrivate::TEvSelfCheckStart(deadline)),
         AppData(ctx)->SystemPoolId);
     return true;
@@ -59,7 +59,7 @@ void TKesusTablet::Handle(TEvPrivate::TEvSelfCheckStart::TPtr& ev) {
     TInstant now = ctx.Now();
     TDuration timeout = msg->Deadline > now ? msg->Deadline - now : TDuration::Zero();
     CreateLongTimer(ctx, timeout,
-        new IEventHandle(SelfId(), SelfId(),
+        new IEventHandleFat(SelfId(), SelfId(),
             new TEvPrivate::TEvSelfCheckTimeout(cookie.Get())),
         AppData(ctx)->SystemPoolId,
         cookie.Get());
diff --git a/ydb/core/kesus/tablet/tx_semaphore_timeout.cpp b/ydb/core/kesus/tablet/tx_semaphore_timeout.cpp
index 83d1ed05672..c4cf543fa82 100644
--- a/ydb/core/kesus/tablet/tx_semaphore_timeout.cpp
+++ b/ydb/core/kesus/tablet/tx_semaphore_timeout.cpp
@@ -89,7 +89,7 @@ bool TKesusTablet::ScheduleWaiterTimeout(ui64 semaphoreId, TSemaphoreWaiterInfo*
     TDuration timeout = TDuration::MilliSeconds(waiter->TimeoutMillis);
     waiter->TimeoutCookie.Reset(ISchedulerCookie::Make3Way());
     CreateLongTimer(ctx, timeout,
-        new IEventHandle(SelfId(), SelfId(),
+        new IEventHandleFat(SelfId(), SelfId(),
             new TEvPrivate::TEvAcquireSemaphoreTimeout(waiter->SessionId, semaphoreId, waiter->TimeoutCookie.Get())),
         AppData(ctx)->SystemPoolId,
         waiter->TimeoutCookie.Get());
diff --git a/ydb/core/kesus/tablet/tx_session_timeout.cpp b/ydb/core/kesus/tablet/tx_session_timeout.cpp
index 9af24f19385..9c9ba87ff1b 100644
--- a/ydb/core/kesus/tablet/tx_session_timeout.cpp
+++ b/ydb/core/kesus/tablet/tx_session_timeout.cpp
@@ -77,7 +77,7 @@ bool TKesusTablet::ScheduleSessionTimeout(TSessionInfo* session, const TActorCon
     TDuration timeout = TDuration::MilliSeconds(session->TimeoutMillis) + gracePeriod;
     session->TimeoutCookie.Reset(ISchedulerCookie::Make3Way());
     CreateLongTimer(ctx, timeout,
-        new IEventHandle(SelfId(), SelfId(),
+        new IEventHandleFat(SelfId(), SelfId(),
             new TEvPrivate::TEvSessionTimeout(session->Id, session->TimeoutCookie.Get())),
         AppData(ctx)->SystemPoolId,
         session->TimeoutCookie.Get());
diff --git a/ydb/core/kesus/tablet/ut_helpers.cpp b/ydb/core/kesus/tablet/ut_helpers.cpp
index 0e032afde5f..12f6fa0476b 100644
--- a/ydb/core/kesus/tablet/ut_helpers.cpp
+++ b/ydb/core/kesus/tablet/ut_helpers.cpp
@@ -55,7 +55,7 @@ private:
         LOG_DEBUG_S(ctx, NKikimrServices::KESUS_PROXY,
                     "TFakeMetering:"
                         << " unhandled event type: " << ev->GetTypeRewrite()
-                        << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                        << " event: " << ev->ToString());
     }
 };
 
@@ -105,7 +105,7 @@ void TTestContext::SetupTabletServices() {
 
 void TTestContext::Sleep(ui64 millis) {
     TActorId sender = Runtime->AllocateEdgeActor();
-    Runtime->Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), TDuration::MilliSeconds(millis), 0);
+    Runtime->Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), TDuration::MilliSeconds(millis), 0);
     ExpectEdgeEvent<TEvents::TEvWakeup>(sender, 0);
 }
 
diff --git a/ydb/core/kesus/tablet/ut_helpers.h b/ydb/core/kesus/tablet/ut_helpers.h
index 8f487a30332..ae9a04904c3 100644
--- a/ydb/core/kesus/tablet/ut_helpers.h
+++ b/ydb/core/kesus/tablet/ut_helpers.h
@@ -58,7 +58,7 @@ struct TTestContext {
     void ExpectNoEdgeEvent(const TActorId& actor, TDuration duration) {
         auto edge = Runtime->AllocateEdgeActor();
         Runtime->EnableScheduleForActor(edge);
-        Runtime->Schedule(new IEventHandle(edge, edge, new TEvent()), duration);
+        Runtime->Schedule(new IEventHandleFat(edge, edge, new TEvent()), duration);
         auto event = Runtime->GrabEdgeEvent<TEvent>({actor, edge});
         UNIT_ASSERT_VALUES_UNEQUAL_C(event->Recipient, actor, "Unexpected event " << event->Get()->ToString());
     }
diff --git a/ydb/core/keyvalue/keyvalue_collector.cpp b/ydb/core/keyvalue/keyvalue_collector.cpp
index b4c72dbd148..3d2a51a5468 100644
--- a/ydb/core/keyvalue/keyvalue_collector.cpp
+++ b/ydb/core/keyvalue/keyvalue_collector.cpp
@@ -190,7 +190,7 @@ public:
             (Status, status), (BackoffMs, backoffMs), (RetryingImmediately, (backoffMs ? "no" : "yes")));
         if (backoffMs) {
             const TDuration &timeout = TDuration::MilliSeconds(backoffMs);
-            TActivationContext::Schedule(timeout, new IEventHandle(TEvents::TEvWakeup::EventType, 0, SelfId(), SelfId(), nullptr, 0));
+            TActivationContext::Schedule(timeout, new IEventHandleFat(TEvents::TEvWakeup::EventType, 0, SelfId(), SelfId(), nullptr, 0));
         } else {
             SendTheRequest();
         }
diff --git a/ydb/core/keyvalue/keyvalue_collector_ut.cpp b/ydb/core/keyvalue/keyvalue_collector_ut.cpp
index 94d8314b8e9..8b9e2b7d82d 100644
--- a/ydb/core/keyvalue/keyvalue_collector_ut.cpp
+++ b/ydb/core/keyvalue/keyvalue_collector_ut.cpp
@@ -85,7 +85,7 @@ public:
     }
 
     void Send(IEventBase *ev) {
-        Runtime->Send(new IEventHandle(CollectorId, Sender, ev));
+        Runtime->Send(new IEventHandleFat(CollectorId, Sender, ev));
     }
 
     TActorId GetTabletActorId() {
diff --git a/ydb/core/keyvalue/keyvalue_flat_impl.h b/ydb/core/keyvalue/keyvalue_flat_impl.h
index ae2ce8331ce..0390356fe2d 100644
--- a/ydb/core/keyvalue/keyvalue_flat_impl.h
+++ b/ydb/core/keyvalue/keyvalue_flat_impl.h
@@ -275,7 +275,7 @@ protected:
         LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE,
                 "KeyValue# " << TabletID()
                 << " Enqueue, event type# " << (ui32)ev->GetTypeRewrite()
-                << " event# " << (ev->HasEvent() ? ev->GetBase()->ToString().c_str() : "serialized?"));
+                << " event# " << ev->ToString());
         InitialEventsQueue.push_back(ev);
     }
 
@@ -500,7 +500,7 @@ public:
         RestoreActorActivity();
         LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
                 << " StateInit flat event type# " << (ui32)ev->GetTypeRewrite()
-                << " event# " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                << " event# " << ev->ToString());
         StateInitImpl(ev, ctx);
     }
 
@@ -532,7 +532,7 @@ public:
                 if (!HandleDefaultEvents(ev, ctx)) {
                     LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
                             << " StateWork unexpected event type# " << (ui32)ev->GetTypeRewrite()
-                            << " event# " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                            << " event# " << ev->ToString());
                 }
                 break;
         }
@@ -546,7 +546,7 @@ public:
             default:
                 LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
                         << " BrokenState unexpected event type# " << (ui32)ev->GetTypeRewrite()
-                        << " event# " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                        << " event# " << ev->ToString());
                 break;
         }
     }
@@ -559,7 +559,7 @@ public:
             TAutoPtr<IEventHandle> &ev = InitialEventsQueue.front();
             LOG_DEBUG_S(ctx, NKikimrServices::KEYVALUE, "KeyValue# " << TabletID()
                     << " Dequeue, event type# " << (ui32)ev->GetTypeRewrite()
-                    << " event# " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                    << " event# " << ev->ToString());
             ctx.ExecutorThread.Send(ev.Release());
             InitialEventsQueue.pop_front();
         }
diff --git a/ydb/core/keyvalue/keyvalue_state.cpp b/ydb/core/keyvalue/keyvalue_state.cpp
index 26431937b2f..48a22566772 100644
--- a/ydb/core/keyvalue/keyvalue_state.cpp
+++ b/ydb/core/keyvalue/keyvalue_state.cpp
@@ -562,7 +562,7 @@ void TKeyValueState::InitExecute(ui64 tabletId, TActorId keyValueActorId, ui32 e
 
             const TActorId nodeWarden = MakeBlobStorageNodeWardenID(ctx.SelfID.NodeId());
             const TActorId proxy = MakeBlobStorageProxyID(group);
-            ctx.ExecutorThread.Send(new IEventHandle(proxy, TActorId(), ev.Release(),
+            ctx.ExecutorThread.Send(new IEventHandleFat(proxy, TActorId(), ev.Release(),
                 IEventHandle::FlagForwardOnNondelivery, (ui64)TKeyValueState::ECollectCookie::Hard, &nodeWarden));
         }
     }
@@ -637,7 +637,7 @@ void TKeyValueState::InitExecute(ui64 tabletId, TActorId keyValueActorId, ui32 e
 
             const TActorId nodeWarden = MakeBlobStorageNodeWardenID(ctx.SelfID.NodeId());
             const TActorId proxy = MakeBlobStorageProxyID(group);
-            ctx.ExecutorThread.Send(new IEventHandle(proxy, KeyValueActorId, ev.Release(),
+            ctx.ExecutorThread.Send(new IEventHandleFat(proxy, KeyValueActorId, ev.Release(),
                 IEventHandle::FlagForwardOnNondelivery, (ui64)TKeyValueState::ECollectCookie::SoftInitial, &nodeWarden));
         }
     }
@@ -1563,7 +1563,7 @@ bool TKeyValueState::CheckCmds(THolder<TIntermediate>& intermediate, const TActo
 
     for (const auto& cmd : intermediate->Commands) {
         const auto &[ok, msg] = std::visit(visitor, cmd);
-        if (!ok) { 
+        if (!ok) {
             ReplyError(ctx, msg, NMsgBusProxy::MSTATUS_ERROR, NKikimrKeyValue::Statuses::RSTATUS_NOT_FOUND, intermediate, info);
             return false;
         }
diff --git a/ydb/core/keyvalue/keyvalue_ut.cpp b/ydb/core/keyvalue/keyvalue_ut.cpp
index a8babc46c12..34deeceb2bf 100644
--- a/ydb/core/keyvalue/keyvalue_ut.cpp
+++ b/ydb/core/keyvalue/keyvalue_ut.cpp
@@ -973,7 +973,7 @@ Y_UNIT_TEST(TestWriteReadDeleteWithRestartsAndCatchCollectGarbageEvents) {
                 TestLog("Collect!!! ", event->Sender, "->", event->Recipient, " Cookie# ", event->Cookie);
                 if (firstCollect) {
                     TestLog("Drop!");
-                    runtime.Send(new IEventHandle(event->Recipient, event->Recipient, new TKikimrEvents::TEvPoisonPill));
+                    runtime.Send(new IEventHandleFat(event->Recipient, event->Recipient, new TKikimrEvents::TEvPoisonPill));
                     firstCollect = false;
                     return TTestActorRuntime::EEventAction::DROP;
                 }
@@ -991,7 +991,7 @@ Y_UNIT_TEST(TestWriteReadDeleteWithRestartsAndCatchCollectGarbageEvents) {
     bool activeZone = false;
     tc.Prepare(INITIAL_TEST_DISPATCH_NAME, setup, activeZone);
     ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
-    tc.Runtime->Send(new IEventHandle(*tabletActor, *tabletActor, new TKikimrEvents::TEvPoisonPill));
+    tc.Runtime->Send(new IEventHandleFat(*tabletActor, *tabletActor, new TKikimrEvents::TEvPoisonPill));
     TestLog("After the first death");
     ExecuteWrite(tc, {{"key1", "value1"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
     ExecuteWrite(tc, {{"key2", "value2"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
@@ -1046,7 +1046,7 @@ Y_UNIT_TEST(TestBlockedEvGetRequest) {
     UNIT_ASSERT(keyValueTabletGeneration);
     auto generation = *keyValueTabletGeneration;
     auto ev = std::make_unique<TEvBlobStorage::TEvBlock>(*keyValueTabletId, generation, TInstant::Max());
-    tc.Runtime->Send(new IEventHandle(*dsProxyActor, *tabletActor, ev.release()));
+    tc.Runtime->Send(new IEventHandleFat(*dsProxyActor, *tabletActor, ev.release()));
 
     // read with the blocked generation should fail and lead to a restart of the key value tablet
     ExecuteRead<NKikimrKeyValue::Statuses::RSTATUS_ERROR>(tc, "key", "", 0, 0, 0);
@@ -1076,7 +1076,7 @@ Y_UNIT_TEST(TestWriteReadDeleteWithRestartsAndCatchCollectGarbageEventsWithSlowI
             if (tabletActor && *tabletActor == event->Recipient && event->GetTypeRewrite() == TEvKeyValue::TEvCollect::EventType) {
                 switch (collectStep++) {
                     case 1: {
-                        runtime.Send(new IEventHandle(event->Recipient, event->Recipient, new TKikimrEvents::TEvPoisonPill));
+                        runtime.Send(new IEventHandleFat(event->Recipient, event->Recipient, new TKikimrEvents::TEvPoisonPill));
                         TestLog("Event drop; Collect; Tablet was poisoned");
                         return TTestActorRuntime::EEventAction::DROP;
                     }
@@ -1100,7 +1100,7 @@ Y_UNIT_TEST(TestWriteReadDeleteWithRestartsAndCatchCollectGarbageEventsWithSlowI
     bool activeZone = false;
     tc.Prepare(INITIAL_TEST_DISPATCH_NAME, setup, activeZone);
     ExecuteWrite(tc, {{"key", "value"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
-    tc.Runtime->Send(new IEventHandle(*tabletActor, *tabletActor, new TKikimrEvents::TEvPoisonPill));
+    tc.Runtime->Send(new IEventHandleFat(*tabletActor, *tabletActor, new TKikimrEvents::TEvPoisonPill));
     ExecuteWrite(tc, {{"key1", "value1"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
     ExecuteWrite(tc, {{"key2", "value2"}}, 0, 2, NKikimrKeyValue::Priorities::PRIORITY_REALTIME);
     ExecuteRead(tc, "key", "value", 0, 0, 0);
diff --git a/ydb/core/kqp/common/kqp.cpp b/ydb/core/kqp/common/kqp.cpp
index f52e4f122ab..570cc156f4b 100644
--- a/ydb/core/kqp/common/kqp.cpp
+++ b/ydb/core/kqp/common/kqp.cpp
@@ -40,7 +40,7 @@ void TKqpShutdownController::Stop() {
     if (!EnableGraceful)
         return;
 
-    ActorSystem_->Send(new NActors::IEventHandle(KqpProxyActorId_, {}, new TEvKqp::TEvInitiateShutdownRequest(ShutdownState_)));
+    ActorSystem_->Send(new NActors::IEventHandleFat(KqpProxyActorId_, {}, new TEvKqp::TEvInitiateShutdownRequest(ShutdownState_)));
     auto timeout = TDuration::MilliSeconds(TableServiceConfig.GetShutdownSettings().GetShutdownTimeoutMs());
     auto startedAt = TInstant::Now();
     auto spent = (TInstant::Now() - startedAt).SecondsFloat();
diff --git a/ydb/core/kqp/common/kqp.h b/ydb/core/kqp/common/kqp.h
index 9952808427e..6791ea79fa6 100644
--- a/ydb/core/kqp/common/kqp.h
+++ b/ydb/core/kqp/common/kqp.h
@@ -712,7 +712,7 @@ struct TEvKqp {
         NLWTrace::TOrbit Orbit;
     };
 
-    struct TEvCompileResponse : public TEventLocal<TEvCompileResponse, TKqpEvents::EvCompileResponse> {
+    struct TEvCompileResponse : public TEventLight<TEvCompileResponse, TKqpEvents::EvCompileResponse> {
         TEvCompileResponse(const TKqpCompileResult::TConstPtr& compileResult, NLWTrace::TOrbit orbit = {})
             : CompileResult(compileResult)
             , Orbit(std::move(orbit)) {}
diff --git a/ydb/core/kqp/compile_service/kqp_compile_actor.cpp b/ydb/core/kqp/compile_service/kqp_compile_actor.cpp
index 0801d6ac570..b10a43ed2d7 100644
--- a/ydb/core/kqp/compile_service/kqp_compile_actor.cpp
+++ b/ydb/core/kqp/compile_service/kqp_compile_actor.cpp
@@ -85,7 +85,7 @@ public:
             << ", text: \"" << EscapeC(Query.Text) << "\""
             << ", startTime: " << StartTime);
 
-        TimeoutTimerActorId = CreateLongTimer(ctx, CompilationTimeout, new IEventHandle(SelfId(), SelfId(),
+        TimeoutTimerActorId = CreateLongTimer(ctx, CompilationTimeout, new IEventHandleFat(SelfId(), SelfId(),
             new TEvents::TEvWakeup()));
 
         TYqlLogScope logScope(ctx, NKikimrServices::KQP_YQL, YqlName, "");
diff --git a/ydb/core/kqp/compile_service/kqp_compile_request.cpp b/ydb/core/kqp/compile_service/kqp_compile_request.cpp
index 5e58e2bb2c8..3b5c7e55622 100644
--- a/ydb/core/kqp/compile_service/kqp_compile_request.cpp
+++ b/ydb/core/kqp/compile_service/kqp_compile_request.cpp
@@ -72,7 +72,7 @@ public:
                 CompileRequestSpan.End();
             }
 
-            ctx.Send(Owner, ev->Release().Release());
+            ctx.Send(Owner, ev.Release());
             Die(ctx);
             return;
         }
@@ -83,12 +83,12 @@ public:
                 CompileRequestSpan.End();
             }
 
-            ctx.Send(Owner, ev->Release().Release());
+            ctx.Send(Owner, ev.Release());
             Die(ctx);
             return;
         }
 
-        DeferredResponse.Reset(ev->Release().Release());
+        DeferredResponse.Reset(ev.Release());
     }
 
     void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev, const TActorContext &ctx) {
diff --git a/ydb/core/kqp/compute_actor/kqp_compute_state.cpp b/ydb/core/kqp/compute_actor/kqp_compute_state.cpp
index 93e311b1c1e..6ca7e563f66 100644
--- a/ydb/core/kqp/compute_actor/kqp_compute_state.cpp
+++ b/ydb/core/kqp/compute_actor/kqp_compute_state.cpp
@@ -15,7 +15,7 @@ void TCommonRetriesState::ResetRetry() {
     AllowInstantRetry = true;
     LastRetryDelay = {};
     if (RetryTimer) {
-        TlsActivationContext->Send(new IEventHandle(RetryTimer, RetryTimer, new TEvents::TEvPoison));
+        TlsActivationContext->Send(new IEventHandleFat(RetryTimer, RetryTimer, new TEvents::TEvPoison));
         RetryTimer = {};
     }
     ResolveAttempt = 0;
diff --git a/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp b/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp
index 7e20401d209..a306a38b776 100644
--- a/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp
+++ b/ydb/core/kqp/compute_actor/kqp_scan_compute_actor.cpp
@@ -375,7 +375,7 @@ private:
             << " schedule after " << retryDelay);
 
         state->RetryTimer = CreateLongTimer(TlsActivationContext->AsActorContext(), retryDelay,
-            new IEventHandle(SelfId(), SelfId(), TEvPrivate::TEvRetryShard::CostsProblem(state->GetShardId()).Release()));
+            new IEventHandleFat(SelfId(), SelfId(), TEvPrivate::TEvRetryShard::CostsProblem(state->GetShardId()).Release()));
     }
 
     void StartCostsRequest(TShardCostsState::TPtr state) {
@@ -972,7 +972,7 @@ private:
             << " schedule after " << retryDelay);
 
         state->RetryTimer = CreateLongTimer(TlsActivationContext->AsActorContext(), retryDelay,
-            new IEventHandle(SelfId(), SelfId(), new TEvPrivate::TEvRetryShard(state->TabletId, state->Generation)));
+            new IEventHandleFat(SelfId(), SelfId(), new TEvPrivate::TEvRetryShard(state->TabletId, state->Generation)));
     }
 
     bool IsQuotingEnabled() const {
diff --git a/ydb/core/kqp/executer_actor/kqp_planner.cpp b/ydb/core/kqp/executer_actor/kqp_planner.cpp
index 0080a0f0908..26fa7fbe3a6 100644
--- a/ydb/core/kqp/executer_actor/kqp_planner.cpp
+++ b/ydb/core/kqp/executer_actor/kqp_planner.cpp
@@ -78,7 +78,7 @@ bool TKqpPlanner::SendStartKqpTasksRequest(ui32 requestId, const TActorId& targe
         if (targetNode) {
             LOG_D("Try to retry to another node, nodeId: " << *targetNode << ", requestId: " << requestId);
             auto anotherTarget = MakeKqpNodeServiceID(*targetNode);
-            TlsActivationContext->Send(std::make_unique<NActors::IEventHandle>(anotherTarget, ExecuterId, ev.Release(),
+            TlsActivationContext->Send(std::make_unique<NActors::IEventHandleFat>(anotherTarget, ExecuterId, ev.Release(),
                 IEventHandle::FlagTrackDelivery | IEventHandle::FlagSubscribeOnSession, requestId,  nullptr, ExecuterSpan.GetTraceId()));
             requestData.RetryNumber++;
             return true;
@@ -93,7 +93,7 @@ bool TKqpPlanner::SendStartKqpTasksRequest(ui32 requestId, const TActorId& targe
 
     requestData.RetryNumber++;
 
-    TlsActivationContext->Send(std::make_unique<NActors::IEventHandle>(target, ExecuterId, ev.Release(),
+    TlsActivationContext->Send(std::make_unique<NActors::IEventHandleFat>(target, ExecuterId, ev.Release(),
         requestData.flag, requestId,  nullptr, ExecuterSpan.GetTraceId()));
     return true;
 }
@@ -175,7 +175,7 @@ void TKqpPlanner::ProcessTasksForScanExecuter() {
             "Not enough resources to execute query locally and no information about other nodes (estimation: "
             + ToString(LocalRunMemoryEst) + ";" + GetEstimationsInfo() + ")");
 
-        TlsActivationContext->Send(std::make_unique<IEventHandle>(ExecuterId, ExecuterId, ev.Release()));
+        TlsActivationContext->Send(std::make_unique<IEventHandleFat>(ExecuterId, ExecuterId, ev.Release()));
         return;
     }
 
@@ -230,7 +230,7 @@ void TKqpPlanner::ProcessTasksForScanExecuter() {
         auto ev = MakeHolder<TEvKqp::TEvAbortExecution>(NYql::NDqProto::StatusIds::PRECONDITION_FAILED,
             "Not enough resources to execute query");
 
-        TlsActivationContext->Send(std::make_unique<IEventHandle>(ExecuterId, ExecuterId, ev.Release()));
+        TlsActivationContext->Send(std::make_unique<IEventHandleFat>(ExecuterId, ExecuterId, ev.Release()));
     }
 
     if (ExecuterSpan) {
diff --git a/ydb/core/kqp/executer_actor/kqp_scan_executer.cpp b/ydb/core/kqp/executer_actor/kqp_scan_executer.cpp
index 84ba7866ab9..6cfbcf0b171 100644
--- a/ydb/core/kqp/executer_actor/kqp_scan_executer.cpp
+++ b/ydb/core/kqp/executer_actor/kqp_scan_executer.cpp
@@ -150,7 +150,7 @@ private:
 
         auto channelIt = ResultChannelProxies.begin();
         auto handle = ev->Forward(channelIt->second->SelfId());
-        channelIt->second->Receive(handle, TlsActivationContext->AsActorContext());
+        channelIt->second->Receive(handle);
     }
 
 private:
@@ -425,7 +425,7 @@ private:
     void GetResourcesSnapshot() {
         GetKqpResourceManager()->RequestClusterResourcesInfo(
             [as = TlsActivationContext->ActorSystem(), self = SelfId()](TVector<NKikimrKqp::TKqpNodeResources>&& resources) {
-                TAutoPtr<IEventHandle> eh = new IEventHandle(self, self, new TEvPrivate::TEvResourcesSnapshot(std::move(resources)));
+                TAutoPtr<IEventHandle> eh = new IEventHandleFat(self, self, new TEvPrivate::TEvResourcesSnapshot(std::move(resources)));
                 as->Send(eh);
             });
     }
@@ -750,10 +750,10 @@ private:
         for (auto channelPair: ResultChannelProxies) {
             LOG_D("terminate result channel " << channelPair.first << " proxy at " << channelPair.second->SelfId());
 
-            TAutoPtr<IEventHandle> ev = new IEventHandle(
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(
                 channelPair.second->SelfId(), SelfId(), new TEvents::TEvPoison
             );
-            channelPair.second->Receive(ev, TActivationContext::AsActorContext());
+            channelPair.second->Receive(ev);
         }
 
         for (auto& [shardId, nodeId] : ShardIdToNodeId) {
diff --git a/ydb/core/kqp/node_service/kqp_node_ut.cpp b/ydb/core/kqp/node_service/kqp_node_ut.cpp
index 88a852aed7f..c31d5b22bc3 100644
--- a/ydb/core/kqp/node_service/kqp_node_ut.cpp
+++ b/ydb/core/kqp/node_service/kqp_node_ut.cpp
@@ -193,19 +193,19 @@ public:
             task->AddOutputs()->AddChannels();
         }
 
-        Runtime->Send(new IEventHandle(KqpNodeActorId, requester, ev.Release()));
+        Runtime->Send(new IEventHandleFat(KqpNodeActorId, requester, ev.Release()));
     }
 
     void SendFinishTask(const TActorId& computeActorId, ui64 txId, ui64 taskId, bool success = true,
         const TString& message = "")
     {
         auto ev = new TEvKqpNode::TEvFinishKqpTask(txId, taskId, success, NYql::TIssues({NYql::TIssue(message)}));
-        Runtime->Send(new IEventHandle(KqpNodeActorId, computeActorId, ev));
+        Runtime->Send(new IEventHandleFat(KqpNodeActorId, computeActorId, ev));
     }
 
     void DispatchKqpNodePostponedEvents(const TActorId& edge) {
         auto ev = new NConsole::TEvConsole::TEvConfigNotificationRequest;
-        Runtime->Send(new IEventHandle(KqpNodeActorId, edge, ev), 0, true);
+        Runtime->Send(new IEventHandleFat(KqpNodeActorId, edge, ev), 0, true);
         Runtime->GrabEdgeEvent<NConsole::TEvConsole::TEvConfigNotificationResponse>(edge);
     }
 
@@ -612,7 +612,7 @@ void KqpNode::ExecuterLost() {
         DispatchKqpNodePostponedEvents(sender1);
     }
 
-    Runtime->Send(new IEventHandle(KqpNodeActorId, {},
+    Runtime->Send(new IEventHandleFat(KqpNodeActorId, {},
                                    new TEvents::TEvUndelivered(
                                        TEvKqpNode::TEvStartKqpTasksResponse::EventType,
                                        TEvents::TEvUndelivered::EReason::ReasonActorUnknown),
@@ -666,7 +666,7 @@ void KqpNode::TerminateTx() {
         auto cancelEvent = MakeHolder<TEvKqpNode::TEvCancelKqpTasksRequest>();
         cancelEvent->Record.SetTxId(1);
         cancelEvent->Record.SetReason("terminate");
-        Runtime->Send(new IEventHandle(KqpNodeActorId, executer, cancelEvent.Release()));
+        Runtime->Send(new IEventHandleFat(KqpNodeActorId, executer, cancelEvent.Release()));
 
         for (auto&[taskId, computeActor] : CompFactory->Task2Actor) {
             auto abortEvent = Runtime->GrabEdgeEvent<TEvKqp::TEvAbortExecution>(computeActor.ActorId);
diff --git a/ydb/core/kqp/proxy_service/kqp_proxy_service.cpp b/ydb/core/kqp/proxy_service/kqp_proxy_service.cpp
index c40265b5019..92a88dcdc72 100644
--- a/ydb/core/kqp/proxy_service/kqp_proxy_service.cpp
+++ b/ydb/core/kqp/proxy_service/kqp_proxy_service.cpp
@@ -214,7 +214,7 @@ public:
         NActors::TMon* mon = AppData()->Mon;
         if (mon) {
             NMonitoring::TIndexMonPage* actorsMonPage = mon->RegisterIndexPage("actors", "Actors");
-            mon->RegisterActorPage(actorsMonPage, "kqp_proxy", "KQP Proxy", false, 
+            mon->RegisterActorPage(actorsMonPage, "kqp_proxy", "KQP Proxy", false,
                 TlsActivationContext->ExecutorThread.ActorSystem, SelfId());
         }
 
@@ -330,7 +330,7 @@ public:
 
         auto groupId = GetDefaultStateStorageGroupId(AppData()->TenantName);
         if (!groupId) {
-            KQP_PROXY_LOG_D("Unable to determine default state storage group id for database " << 
+            KQP_PROXY_LOG_D("Unable to determine default state storage group id for database " <<
                 AppData()->TenantName);
             return;
         }
@@ -353,7 +353,7 @@ public:
                 Send(KqpRmServiceActor, std::make_unique<TEvKqp::TEvKqpProxyPublishRequest>());
             }
             return;
-        } 
+        }
 
         if (ResourcesPublishScheduled) {
             return;
@@ -721,7 +721,7 @@ public:
         } else {
             GetKqpResourceManager()->RequestClusterResourcesInfo(
                 [as = TlsActivationContext->ActorSystem(), self = SelfId()](TVector<NKikimrKqp::TKqpNodeResources>&& resources) {
-                    TAutoPtr<IEventHandle> eh = new IEventHandle(self, self, new TEvPrivate::TEvResourcesSnapshot(std::move(resources)));
+                    TAutoPtr<IEventHandle> eh = new IEventHandleFat(self, self, new TEvPrivate::TEvResourcesSnapshot(std::move(resources)));
                     as->Send(eh);
                 });
         }
@@ -767,7 +767,7 @@ public:
     void Handle(TEvPrivate::TEvResourcesSnapshot::TPtr& ev) {
         if (ev->Get()->Snapshot.empty()) {
             PeerProxyNodeResources.clear();
-            KQP_PROXY_LOG_E("Can not find default state storage group for database " << 
+            KQP_PROXY_LOG_E("Can not find default state storage group for database " <<
                 AppData()->TenantName);
             return;
         }
@@ -1013,7 +1013,7 @@ public:
     void StartQueryTimeout(ui64 requestId, TDuration timeout, NYql::NDqProto::StatusIds::StatusCode status = NYql::NDqProto::StatusIds::TIMEOUT) {
         TActorId timeoutTimer = CreateLongTimer(
             TlsActivationContext->AsActorContext(), timeout,
-            new IEventHandle(SelfId(), SelfId(), new TEvPrivate::TEvOnRequestTimeout{requestId, timeout, status, 0})
+            new IEventHandleFat(SelfId(), SelfId(), new TEvPrivate::TEvOnRequestTimeout{requestId, timeout, status, 0})
         );
 
         KQP_PROXY_LOG_D("Scheduled timeout timer for requestId: " << requestId << " timeout: " << timeout << " actor id: " << timeoutTimer);
@@ -1098,7 +1098,7 @@ public:
             hFunc(TEvPrivate::TEvCloseIdleSessions, Handle);
         default:
             Y_FAIL("TKqpProxyService: unexpected event type: %" PRIx32 " event: %s",
-                ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
@@ -1330,7 +1330,7 @@ private:
     bool ResourcesPublishScheduled = false;
     TString PublishBoardPath;
     std::optional<TInstant> LastPublishResourcesAt;
-    
+
     TActorId KqpRmServiceActor;
     TActorId BoardLookupActor;
     TActorId BoardPublishActor;
@@ -1349,7 +1349,7 @@ IActor* CreateKqpProxyService(const NKikimrConfig::TLogConfig& logConfig,
     std::shared_ptr<IQueryReplayBackendFactory> queryReplayFactory,
     std::shared_ptr<TKqpProxySharedResources> kqpProxySharedResources)
 {
-    return new TKqpProxyService(logConfig, tableServiceConfig, std::move(settings), 
+    return new TKqpProxyService(logConfig, tableServiceConfig, std::move(settings),
         std::move(queryReplayFactory),std::move(kqpProxySharedResources));
 }
 
diff --git a/ydb/core/kqp/proxy_service/kqp_proxy_ut.cpp b/ydb/core/kqp/proxy_service/kqp_proxy_ut.cpp
index 161969c3ffe..e98729c5af4 100644
--- a/ydb/core/kqp/proxy_service/kqp_proxy_ut.cpp
+++ b/ydb/core/kqp/proxy_service/kqp_proxy_ut.cpp
@@ -49,7 +49,7 @@ TVector<NKikimrKqp::TKqpProxyNodeResources> Transform(TVector<TSimpleResource> d
 }
 
 TString CreateSession(TTestActorRuntime* runtime, const TActorId& kqpProxy, const TActorId& sender) {
-    runtime->Send(new IEventHandle(kqpProxy, sender, new TEvKqp::TEvCreateSessionRequest()));
+    runtime->Send(new IEventHandleFat(kqpProxy, sender, new TEvKqp::TEvCreateSessionRequest()));
     auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvCreateSessionResponse>(sender);
     auto record = reply->Get()->Record;
     UNIT_ASSERT_VALUES_EQUAL(record.GetYdbStatus(), Ydb::StatusIds::SUCCESS);
@@ -100,7 +100,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
             ev->Record.MutableRequest()->SetKeepSession(true);
             ev->Record.MutableRequest()->SetTimeoutMs(10);
 
-            runtime->Send(new IEventHandle(kqpProxy, sender, ev.Release()));
+            runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.Release()));
             TAutoPtr<IEventHandle> handle;
             auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvProcessResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetYdbStatus(), Ydb::StatusIds::BAD_REQUEST);
@@ -142,7 +142,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
         ev->Record.MutableRequest()->SetKeepSession(true);
         ev->Record.MutableRequest()->SetTimeoutMs(10);
 
-        runtime->Send(new IEventHandle(kqpProxy, sender, ev.Release()));
+        runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.Release()));
         TAutoPtr<IEventHandle> handle;
         auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvProcessResponse>(sender);
         UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetYdbStatus(), Ydb::StatusIds::BAD_REQUEST);
@@ -204,7 +204,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
             ev->Record.MutableRequest()->SetAction(NKikimrKqp::QUERY_ACTION_EXECUTE);
             ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DDL);
             ev->Record.MutableRequest()->SetQuery(queryText);
-            runtime->Send(new IEventHandle(kqpProxy, sender, ev.release()));
+            runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.release()));
             TAutoPtr<IEventHandle> handle;
             auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvQueryResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetRef().GetYdbStatus(), Ydb::StatusIds::SUCCESS);
@@ -219,7 +219,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
             ev->Record.MutableRequest()->SetKeepSession(true);
             ev->Record.MutableRequest()->SetTimeoutMs(5000);
 
-            runtime->Send(new IEventHandle(kqpProxy, sender, ev.release()));
+            runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.release()));
             TAutoPtr<IEventHandle> handle;
             auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvQueryResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetRef().GetYdbStatus(), Ydb::StatusIds::TIMEOUT);
@@ -278,7 +278,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
             ev->Record.MutableRequest()->SetQuery("SELECT 1; COMMIT;");
             ev->Record.MutableRequest()->SetKeepSession(true);
 
-            runtime->Send(new IEventHandle(kqpProxy1, sender, ev.Release()));
+            runtime->Send(new IEventHandleFat(kqpProxy1, sender, ev.Release()));
 
             TAutoPtr<IEventHandle> handle;
             auto reply = runtime->GrabEdgeEventsRethrow<TEvKqp::TEvQueryResponse, TEvKqp::TEvProcessResponse>(handle);
@@ -355,7 +355,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
                 ev->Record.MutableRequest()->SetKeepSession(true);
                 ev->Record.MutableRequest()->SetTimeoutMs(1);
 
-                runtime->Send(new IEventHandle(kqpProxy1, sender, ev.Release()));
+                runtime->Send(new IEventHandleFat(kqpProxy1, sender, ev.Release()));
 
                 TAutoPtr<IEventHandle> handle;
                 auto reply = runtime->GrabEdgeEventsRethrow<TEvKqp::TEvQueryResponse, TEvKqp::TEvProcessResponse>(handle);
@@ -378,7 +378,7 @@ Y_UNIT_TEST_SUITE(KqpProxy) {
                 auto ev = MakeHolder<NKqp::TEvKqp::TEvPingSessionRequest>();
                 ev->Record.MutableRequest()->SetSessionId(sessionId);
                 ev->Record.MutableRequest()->SetTimeoutMs(1);
-                runtime->Send(new IEventHandle(kqpProxy1, sender, ev.Release()));
+                runtime->Send(new IEventHandleFat(kqpProxy1, sender, ev.Release()));
 
                 TAutoPtr<IEventHandle> handle;
                 auto reply = runtime->GrabEdgeEventsRethrow<TEvKqp::TEvPingSessionResponse, TEvKqp::TEvProcessResponse>(handle);
diff --git a/ydb/core/kqp/rm_service/kqp_resource_tracker.cpp b/ydb/core/kqp/rm_service/kqp_resource_tracker.cpp
index 29d1650735f..6448d0482e9 100644
--- a/ydb/core/kqp/rm_service/kqp_resource_tracker.cpp
+++ b/ydb/core/kqp/rm_service/kqp_resource_tracker.cpp
@@ -53,7 +53,7 @@ public:
             cFunc(TEvents::TSystem::Poison, PassAway);
             default:
                 LOG_C("Unexpected event type: " << ev->GetTypeRewrite()
-                    << ", event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "<serialized>"));
+                    << ", event: " << ev->GetTypeName());
         }
     }
 
diff --git a/ydb/core/kqp/rm_service/kqp_rm_service.cpp b/ydb/core/kqp/rm_service/kqp_rm_service.cpp
index c68af8de8e0..81a6c7bda26 100644
--- a/ydb/core/kqp/rm_service/kqp_rm_service.cpp
+++ b/ydb/core/kqp/rm_service/kqp_rm_service.cpp
@@ -594,7 +594,7 @@ public:
         LOG_DEBUG_S(*ActorSystem, NKikimrServices::KQP_RESOURCE_MANAGER, "Schedule Snapshot request");
         auto ev = MakeHolder<TEvPrivate::TEvTakeResourcesSnapshot>();
         ev->Callback = std::move(callback);
-        TAutoPtr<IEventHandle> handle = new IEventHandle(SelfId(), SelfId(), ev.Release());
+        TAutoPtr<IEventHandle> handle = new IEventHandleFat(SelfId(), SelfId(), ev.Release());
         ActorSystem->Send(handle);
     }
 
diff --git a/ydb/core/kqp/rm_service/kqp_snapshot_manager.cpp b/ydb/core/kqp/rm_service/kqp_snapshot_manager.cpp
index e461d85ab90..dbbb9878f99 100644
--- a/ydb/core/kqp/rm_service/kqp_snapshot_manager.cpp
+++ b/ydb/core/kqp/rm_service/kqp_snapshot_manager.cpp
@@ -24,7 +24,7 @@ public:
     {}
 
     void Bootstrap() {
-        auto *ev = new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvPoison());
+        auto *ev = new IEventHandleFat(this->SelfId(), this->SelfId(), new TEvents::TEvPoison());
         RequestTimeoutCookieHolder_.Reset(ISchedulerCookie::Make2Way());
         CreateLongTimer(TlsActivationContext->AsActorContext(), RequestTimeout, ev, 0, RequestTimeoutCookieHolder_.Get());
 
diff --git a/ydb/core/kqp/runtime/kqp_channel_storage.cpp b/ydb/core/kqp/runtime/kqp_channel_storage.cpp
index 9018077eb47..8175ff81788 100644
--- a/ydb/core/kqp/runtime/kqp_channel_storage.cpp
+++ b/ydb/core/kqp/runtime/kqp_channel_storage.cpp
@@ -74,7 +74,7 @@ private:
             default:
                 Y_FAIL("TKqpChannelStorageActor::WorkState unexpected event type: %" PRIx32 " event: %s",
                     ev->GetTypeRewrite(),
-                    ev->HasEvent() ? ev->GetBase()->ToString().c_str() : "serialized?");
+                    ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/kqp/runtime/kqp_read_actor.cpp b/ydb/core/kqp/runtime/kqp_read_actor.cpp
index b6d0e78d0ed..101ab5dcdbc 100644
--- a/ydb/core/kqp/runtime/kqp_read_actor.cpp
+++ b/ydb/core/kqp/runtime/kqp_read_actor.cpp
@@ -81,12 +81,12 @@ class TKqpReadActor : public TActorBootstrapped<TKqpReadActor>, public NYql::NDq
 public:
     struct TResult {
         ui64 ShardId;
-        THolder<TEventHandle<TEvDataShard::TEvReadResult>> ReadResult;
+        THolder<TEventHandleFat<TEvDataShard::TEvReadResult>> ReadResult;
         TMaybe<NKikimr::NMiniKQL::TUnboxedValueVector> Batch;
         size_t ProcessedRows = 0;
         size_t PackedRows = 0;
 
-        TResult(ui64 shardId, THolder<TEventHandle<TEvDataShard::TEvReadResult>> readResult)
+        TResult(ui64 shardId, THolder<TEventHandleFat<TEvDataShard::TEvReadResult>> readResult)
             : ShardId(shardId)
             , ReadResult(std::move(readResult))
         {
@@ -721,7 +721,7 @@ public:
         }
 
         CA_LOG_D("schedule retry #" << id << " after " << delay);
-        TlsActivationContext->Schedule(delay, new IEventHandle(SelfId(), SelfId(), new TEvRetryShard(id, Reads[id].LastSeqNo)));
+        TlsActivationContext->Schedule(delay, new IEventHandleFat(SelfId(), SelfId(), new TEvRetryShard(id, Reads[id].LastSeqNo)));
     }
 
     void DoRetryRead(ui64 id) {
@@ -911,7 +911,7 @@ public:
             << " seqno = " << ev->Get()->Record.GetSeqNo()
             << " finished = " << ev->Get()->Record.GetFinished());
         CA_LOG_T(TStringBuilder() << "read #" << id << " pushed " << DebugPrintCells(ev->Get()) << " continuation token " << DebugPrintContionuationToken(record.GetContinuationToken()));
-        Results.push({Reads[id].Shard->TabletId, THolder<TEventHandle<TEvDataShard::TEvReadResult>>(ev.Release())});
+        Results.push({Reads[id].Shard->TabletId, THolder<TEventHandleFat<TEvDataShard::TEvReadResult>>(ev.Release())});
         NotifyCA();
     }
 
@@ -1172,7 +1172,7 @@ public:
         if (RunningReads() == 0 && PendingShards.Empty() && ScanStarted) {
             finished = true;
         }
-        
+
         CA_LOG_D(TStringBuilder() << "returned async data"
             << " processed rows " << ProcessedRowCount
             << " received rows " << ReceivedRowCount
diff --git a/ydb/core/kqp/runtime/kqp_spilling_file_ut.cpp b/ydb/core/kqp/runtime/kqp_spilling_file_ut.cpp
index d643c3596a3..1a1bc60bea3 100644
--- a/ydb/core/kqp/runtime/kqp_spilling_file_ut.cpp
+++ b/ydb/core/kqp/runtime/kqp_spilling_file_ut.cpp
@@ -101,7 +101,7 @@ Y_UNIT_TEST(Simple) {
     // put blob 1
     {
         auto ev = new TEvKqpSpilling::TEvWrite(1, CreateBlob(10, 'a'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_VALUES_EQUAL(1, resp->Get()->BlobId);
@@ -110,7 +110,7 @@ Y_UNIT_TEST(Simple) {
     // put blob 2
     {
         auto ev = new TEvKqpSpilling::TEvWrite(2, CreateBlob(11, 'z'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_VALUES_EQUAL(2, resp->Get()->BlobId);
@@ -119,7 +119,7 @@ Y_UNIT_TEST(Simple) {
     // get blob 1
     {
         auto ev = new TEvKqpSpilling::TEvRead(1);
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvReadResult>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_VALUES_EQUAL(1, resp->Get()->BlobId);
@@ -131,7 +131,7 @@ Y_UNIT_TEST(Simple) {
     // get blob 2
     {
         auto ev = new TEvKqpSpilling::TEvRead(2);
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvReadResult>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_VALUES_EQUAL(2, resp->Get()->BlobId);
@@ -142,7 +142,7 @@ Y_UNIT_TEST(Simple) {
 
     // terminate
     {
-        runtime.Send(new IEventHandle(spillingActor, tester, new TEvents::TEvPoison));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, new TEvents::TEvPoison));
 
         std::atomic<bool> done = false;
         runtime.SetObserverFunc([&](TTestActorRuntimeBase&, TAutoPtr<IEventHandle>& event) {
@@ -176,7 +176,7 @@ Y_UNIT_TEST(Write_TotalSizeLimitExceeded) {
 
     {
         auto ev = new TEvKqpSpilling::TEvWrite(1, CreateBlob(51, 'a'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(1, resp->Get()->BlobId);
@@ -184,7 +184,7 @@ Y_UNIT_TEST(Write_TotalSizeLimitExceeded) {
 
     {
         auto ev = new TEvKqpSpilling::TEvWrite(2, CreateBlob(50, 'b'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvError>(tester);
         UNIT_ASSERT_STRINGS_EQUAL("Total size limit exceeded", resp->Get()->Message);
@@ -204,7 +204,7 @@ Y_UNIT_TEST(Write_FileSizeLimitExceeded) {
 
     {
         auto ev = new TEvKqpSpilling::TEvWrite(1, CreateBlob(51, 'a'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(1, resp->Get()->BlobId);
@@ -212,7 +212,7 @@ Y_UNIT_TEST(Write_FileSizeLimitExceeded) {
 
     {
         auto ev = new TEvKqpSpilling::TEvWrite(2, CreateBlob(50, 'b'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvError>(tester);
         UNIT_ASSERT_STRINGS_EQUAL("File size limit exceeded", resp->Get()->Message);
@@ -235,7 +235,7 @@ Y_UNIT_TEST(MultipleFileParts) {
     for (ui32 i = 0; i < 5; ++i) {
         // Cerr << "---- store blob #" << i << Endl;
         auto ev = new TEvKqpSpilling::TEvWrite(i, CreateBlob(20, 'a' + i));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(i, resp->Get()->BlobId);
@@ -246,7 +246,7 @@ Y_UNIT_TEST(MultipleFileParts) {
     for (i32 i = 4; i >= 0; --i) {
         // Cerr << "---- load blob #" << i << Endl;
         auto ev = new TEvKqpSpilling::TEvRead(i, true);
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvReadResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(i, resp->Get()->BlobId);
@@ -278,7 +278,7 @@ Y_UNIT_TEST(SingleFilePart) {
     for (ui32 i = 0; i < 5; ++i) {
         // Cerr << "---- store blob #" << i << Endl;
         auto ev = new TEvKqpSpilling::TEvWrite(i, CreateBlob(20, 'a' + i));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(i, resp->Get()->BlobId);
@@ -292,7 +292,7 @@ Y_UNIT_TEST(SingleFilePart) {
     for (i32 i = 4; i >= 0; --i) {
         // Cerr << "---- load blob #" << i << Endl;
         auto ev = new TEvKqpSpilling::TEvRead(i, true);
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvReadResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(i, resp->Get()->BlobId);
@@ -318,7 +318,7 @@ Y_UNIT_TEST(ReadError) {
 
     {
         auto ev = new TEvKqpSpilling::TEvWrite(0, CreateBlob(20, 'a'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvWriteResult>(tester);
         UNIT_ASSERT_VALUES_EQUAL(0, resp->Get()->BlobId);
@@ -328,7 +328,7 @@ Y_UNIT_TEST(ReadError) {
 
     {
         auto ev = new TEvKqpSpilling::TEvRead(0, true);
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvError>(tester);
         auto& err = resp->Get()->Message;
@@ -397,7 +397,7 @@ Y_UNIT_TEST(StartError) {
     // put blob 1
     {
         auto ev = new TEvKqpSpilling::TEvWrite(1, CreateBlob(10, 'a'));
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvError>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_EQUAL("Service not started", resp->Get()->Message);
@@ -406,7 +406,7 @@ Y_UNIT_TEST(StartError) {
     // get blob 1
     {
         auto ev = new TEvKqpSpilling::TEvRead(1);
-        runtime.Send(new IEventHandle(spillingActor, tester, ev));
+        runtime.Send(new IEventHandleFat(spillingActor, tester, ev));
 
         auto resp = runtime.GrabEdgeEvent<TEvKqpSpilling::TEvError>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_EQUAL("Service not started", resp->Get()->Message);
@@ -417,7 +417,7 @@ Y_UNIT_TEST(StartError) {
         THttpRequest httpReq(HTTP_METHOD_GET);
         NMonitoring::TMonService2HttpRequest monReq(nullptr, &httpReq, nullptr, nullptr, "", nullptr);
 
-        runtime.Send(new IEventHandle(spillingService, tester, new NMon::TEvHttpInfo(monReq)));
+        runtime.Send(new IEventHandleFat(spillingService, tester, new NMon::TEvHttpInfo(monReq)));
 
         auto resp = runtime.GrabEdgeEvent<NMon::TEvHttpInfoRes>(tester, TDuration::Seconds(1));
         UNIT_ASSERT_EQUAL("<html><h2>Service is not started due to IO error</h2></html>",
diff --git a/ydb/core/kqp/runtime/kqp_stream_lookup_actor.cpp b/ydb/core/kqp/runtime/kqp_stream_lookup_actor.cpp
index 36d6c1629c4..00097e51805 100644
--- a/ydb/core/kqp/runtime/kqp_stream_lookup_actor.cpp
+++ b/ydb/core/kqp/runtime/kqp_stream_lookup_actor.cpp
@@ -158,7 +158,7 @@ private:
 
     struct TResult {
         const ui64 ShardId;
-        THolder<TEventHandle<TEvDataShard::TEvReadResult>> ReadResult;
+        THolder<TEventHandleFat<TEvDataShard::TEvReadResult>> ReadResult;
         size_t UnprocessedResultRow = 0;
     };
 
@@ -316,7 +316,7 @@ private:
                 IEventHandle::FlagTrackDelivery);
         }
 
-        Results.emplace_back(TResult{read.ShardId, THolder<TEventHandle<TEvDataShard::TEvReadResult>>(ev.Release())});
+        Results.emplace_back(TResult{read.ShardId, THolder<TEventHandleFat<TEvDataShard::TEvReadResult>>(ev.Release())});
         Send(ComputeActorId, new TEvNewAsyncInputDataArrived(InputIndex));
     }
 
@@ -581,7 +581,7 @@ private:
         Send(MakeSchemeCacheID(), new TEvTxProxySchemeCache::TEvResolveKeySet(request));
 
         SchemeCacheRequestTimeoutTimer = CreateLongTimer(TlsActivationContext->AsActorContext(), SchemeCacheRequestTimeout,
-            new IEventHandle(SelfId(), SelfId(), new TEvPrivate::TEvSchemeCacheRequestTimeout()));
+            new IEventHandleFat(SelfId(), SelfId(), new TEvPrivate::TEvSchemeCacheRequestTimeout()));
     }
 
     bool AllReadsFinished() const {
diff --git a/ydb/core/kqp/session_actor/kqp_session_actor.cpp b/ydb/core/kqp/session_actor/kqp_session_actor.cpp
index 5425ddd5319..d504d390be4 100644
--- a/ydb/core/kqp/session_actor/kqp_session_actor.cpp
+++ b/ydb/core/kqp/session_actor/kqp_session_actor.cpp
@@ -377,7 +377,7 @@ public:
                 HttpGateway, ModuleResolverState, Counters));
             WorkerId = RegisterWithSameMailbox(workerActor.release());
         }
-        TlsActivationContext->Send(new IEventHandle(*WorkerId, SelfId(), QueryState->RequestEv.release(), ev->Flags, ev->Cookie,
+        TlsActivationContext->Send(new IEventHandleFat(*WorkerId, SelfId(), QueryState->RequestEv.release(), ev->Flags, ev->Cookie,
                     nullptr, std::move(ev->TraceId)));
         Become(&TKqpSessionActor::ExecuteState);
     }
@@ -2125,8 +2125,8 @@ private:
     }
 
     void UnexpectedEvent(const TString& state, TAutoPtr<NActors::IEventHandle>& ev) {
-        InternalError(TStringBuilder() << "TKqpSessionActor in state " << state << " recieve unexpected event " <<
-                TypeName(*ev.Get()->GetBase()) << Sprintf("(0x%08" PRIx32 ")", ev->GetTypeRewrite()));
+        InternalError(TStringBuilder() << "TKqpSessionActor in state " << state << " received unexpected event " <<
+                ev->GetTypeName() << Sprintf("(0x%08" PRIx32 ")", ev->GetTypeRewrite()));
     }
 
     void InternalError(const TString& message) {
diff --git a/ydb/core/kqp/session_actor/kqp_worker_actor.cpp b/ydb/core/kqp/session_actor/kqp_worker_actor.cpp
index 9526d41bdd5..aeef13a9c65 100644
--- a/ydb/core/kqp/session_actor/kqp_worker_actor.cpp
+++ b/ydb/core/kqp/session_actor/kqp_worker_actor.cpp
@@ -1038,7 +1038,7 @@ private:
     void UnexpectedEvent(const TString& state, TAutoPtr<NActors::IEventHandle>& ev, const TActorContext& ctx) {
         TString message = TStringBuilder() << "TKqpWorkerActor in state "
             << state << " received unexpected event "
-            << TypeName(*ev.Get()->GetBase()) << Sprintf("(0x%08" PRIx32 ")", ev->GetTypeRewrite());
+            << ev->GetTypeName() << Sprintf("(0x%08" PRIx32 ")", ev->GetTypeRewrite());
 
         InternalError(message, ctx);
     }
diff --git a/ydb/core/kqp/ut/common/kqp_ut_common.cpp b/ydb/core/kqp/ut/common/kqp_ut_common.cpp
index 51d20a75abc..cc2ca688bd6 100644
--- a/ydb/core/kqp/ut/common/kqp_ut_common.cpp
+++ b/ydb/core/kqp/ut/common/kqp_ut_common.cpp
@@ -989,7 +989,7 @@ THolder<NSchemeCache::TSchemeCacheNavigate> Navigate(TTestActorRuntime& runtime,
     entry.RequestType = TNavigate::TEntry::ERequestType::ByPath;
     entry.Operation = op;
     entry.ShowPrivatePath = true;
-    runtime.Send(new IEventHandle(MakeSchemeCacheID(), sender, new TEvRequest(request.Release())));
+    runtime.Send(MakeSchemeCacheID(), sender, new TEvRequest(request.Release()));
 
     auto ev = runtime.GrabEdgeEventRethrow<TEvResponse>(sender);
     UNIT_ASSERT(ev);
diff --git a/ydb/core/kqp/ut/olap/kqp_olap_ut.cpp b/ydb/core/kqp/ut/olap/kqp_olap_ut.cpp
index 08a2630ec5f..6daeb7b4ff8 100644
--- a/ydb/core/kqp/ut/olap/kqp_olap_ut.cpp
+++ b/ydb/core/kqp/ut/olap/kqp_olap_ut.cpp
@@ -2830,7 +2830,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
             }
@@ -2896,7 +2896,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
             }
@@ -2959,7 +2959,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
             }
@@ -3041,7 +3041,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
             }
@@ -3116,7 +3116,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
 
@@ -3132,7 +3132,7 @@ Y_UNIT_TEST_SUITE(KqpOlap) {
                             Cerr << (TStringBuilder() << "-- EvScanData from " << ev->Sender << ": hijack event");
                             Cerr.Flush();
                             auto resp = std::make_unique<NKqp::TEvKqpCompute::TEvScanError>(msg->Generation);
-                            runtime->Send(new IEventHandle(ev->Recipient, ev->Sender, resp.release()));
+                            runtime->Send(new IEventHandleFat(ev->Recipient, ev->Sender, resp.release()));
                         } else {
                             prevIsFinished = msg->Finished;
                         }
diff --git a/ydb/core/kqp/ut/scan/kqp_scan_ut.cpp b/ydb/core/kqp/ut/scan/kqp_scan_ut.cpp
index f3dc2fcf3ed..c5b85b3cab6 100644
--- a/ydb/core/kqp/ut/scan/kqp_scan_ut.cpp
+++ b/ydb/core/kqp/ut/scan/kqp_scan_ut.cpp
@@ -2226,7 +2226,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                 auto resp = MakeHolder<NKqp::TEvKqpExecuter::TEvStreamDataAck>();
                 resp->Record.SetEnough(false);
                 resp->Record.SetSeqNo(record.GetSeqNo());
-                runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                 return true;
             }
 
@@ -2234,7 +2234,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
         };
 
         auto createSession = [&]() {
-            runtime->Send(new IEventHandle(kqpProxy, sender, new TEvKqp::TEvCreateSessionRequest()));
+            runtime->Send(new IEventHandleFat(kqpProxy, sender, new TEvKqp::TEvCreateSessionRequest()));
             auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvCreateSessionResponse>(sender);
             auto record = reply->Get()->Record;
             UNIT_ASSERT_VALUES_EQUAL(record.GetYdbStatus(), Ydb::StatusIds::SUCCESS);
@@ -2248,7 +2248,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
             ev->Record.MutableRequest()->SetType(NKikimrKqp::QUERY_TYPE_SQL_DDL);
             ev->Record.MutableRequest()->SetQuery(queryText);
 
-            runtime->Send(new IEventHandle(kqpProxy, sender, ev.release()));
+            runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.release()));
             auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvQueryResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetRef().GetYdbStatus(), Ydb::StatusIds::SUCCESS);
         };
@@ -2261,7 +2261,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
             ev->Record.MutableRequest()->SetKeepSession(false);
             ActorIdToProto(sender, ev->Record.MutableRequestActorId());
 
-            runtime->Send(new IEventHandle(kqpProxy, sender, ev.release()));
+            runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.release()));
             auto reply = runtime->GrabEdgeEventRethrow<TEvKqp::TEvQueryResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(reply->Get()->Record.GetRef().GetYdbStatus(), Ydb::StatusIds::SUCCESS);
         };
diff --git a/ydb/core/kqp/ut/scan/kqp_split_ut.cpp b/ydb/core/kqp/ut/scan/kqp_split_ut.cpp
index 7ed7bcf4198..c4f6a1ee1e0 100644
--- a/ydb/core/kqp/ut/scan/kqp_split_ut.cpp
+++ b/ydb/core/kqp/ut/scan/kqp_split_ut.cpp
@@ -30,7 +30,7 @@ Y_UNIT_TEST_SUITE(KqpSplit) {
             sender = runtime.AllocateEdgeActor();
         }
 
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()), 0, viaActorSystem);
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()), 0, viaActorSystem);
         auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
         Cerr << (TStringBuilder() << "scheme op " << ev->Get()->Record.ShortDebugString()) << Endl;
         UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetStatus(), expectedStatus);
@@ -81,7 +81,7 @@ Y_UNIT_TEST_SUITE(KqpSplit) {
         auto request = MakeHolder<TEvTxUserProxy::TEvNavigate>();
         request->Record.MutableDescribePath()->SetPath(path);
         request->Record.MutableDescribePath()->MutableOptions()->SetShowPrivateTable(true);
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
         auto reply = runtime.GrabEdgeEventRethrow<NSchemeShard::TEvSchemeShard::TEvDescribeSchemeResult>(handle);
 
         return *reply->MutableRecord();
@@ -125,7 +125,7 @@ Y_UNIT_TEST_SUITE(KqpSplit) {
         }
 
         void Handle(TAutoPtr<IEventHandle> ev) {
-            Send(Client, ev->ReleaseBase());
+            Forward(ev, Client);
         }
 
         void Handle(TEvDataShard::TEvReadResult::TPtr& ev) {
@@ -243,7 +243,7 @@ Y_UNIT_TEST_SUITE(KqpSplit) {
                 }
             }
             auto id = pipe->SelfId();
-            Send(id, ev->ReleaseBase());
+            TActor<TReadActorPipeCacheStub>::Forward(ev, id);
         }
 
         void SendCaptured(NActors::TTestActorRuntime* runtime, bool sendResults = true) {
@@ -300,7 +300,7 @@ Y_UNIT_TEST_SUITE(KqpSplit) {
         ev->Record.MutableRequest()->SetQuery(queryText);
         ev->Record.MutableRequest()->SetKeepSession(false);
         ActorIdToProto(sender, ev->Record.MutableRequestActorId());
-        runtime->Send(new IEventHandle(kqpProxy, sender, ev.release()));
+        runtime->Send(new IEventHandleFat(kqpProxy, sender, ev.release()));
     };
 
     void CollectKeysTo(TVector<ui64>* collectedKeys, TTestActorRuntime* runtime, TActorId sender) {
@@ -314,7 +314,7 @@ Y_UNIT_TEST_SUITE(KqpSplit) {
                 auto resp = MakeHolder<NKqp::TEvKqpExecuter::TEvStreamDataAck>();
                 resp->Record.SetEnough(false);
                 resp->Record.SetSeqNo(record.GetSeqNo());
-                runtime->Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                runtime->Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                 return true;
             }
 
diff --git a/ydb/core/load_test/ut_ycsb.cpp b/ydb/core/load_test/ut_ycsb.cpp
index 3342f0bf4a7..345549f436e 100644
--- a/ydb/core/load_test/ut_ycsb.cpp
+++ b/ydb/core/load_test/ut_ycsb.cpp
@@ -39,7 +39,7 @@ ui64 RunSchemeTx(
         sender = runtime.AllocateEdgeActor();
     }
 
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()), 0, viaActorSystem);
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()), 0, viaActorSystem);
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
     UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetStatus(), expectedStatus);
 
@@ -119,7 +119,7 @@ NKikimrScheme::TEvDescribeSchemeResult DescribeTable(Tests::TServer::TPtr server
     auto request = MakeHolder<TEvTxUserProxy::TEvNavigate>();
     request->Record.MutableDescribePath()->SetPath(path);
     request->Record.MutableDescribePath()->MutableOptions()->SetShowPrivateTable(true);
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
     auto reply = runtime.GrabEdgeEventRethrow<TEvSchemeShard::TEvDescribeSchemeResult>(handle);
 
     return *reply->MutableRecord();
@@ -281,8 +281,7 @@ struct TTestHelper {
         if (!handle) {
             return nullptr;
         }
-        auto event = handle->Release<TEvDataShard::TEvReadResult>();
-        return std::unique_ptr<TEvDataShard::TEvReadResult>(event.Release());
+        return std::unique_ptr<TEvDataShard::TEvReadResult>(IEventHandle::Release<TEvDataShard::TEvReadResult>(handle));
     }
 
     std::unique_ptr<TEvDataShard::TEvReadResult> SendRead(TEvDataShard::TEvRead* request)
@@ -343,10 +342,10 @@ struct TTestHelper {
             TAutoPtr<IEventHandle> handle;
             runtime.GrabEdgeEventRethrow<TEvLoad::TEvLoadTestFinished>(handle);
             UNIT_ASSERT(handle);
-            auto response = handle->Release<TEvLoad::TEvLoadTestFinished>();
+            auto response = IEventHandle::Release<TEvLoad::TEvLoadTestFinished>(handle);
             UNIT_ASSERT(response->ErrorReason.Empty());
 
-            return std::unique_ptr<TEvLoad::TEvLoadTestFinished>(response.Release());
+            return std::unique_ptr<TEvLoad::TEvLoadTestFinished>(response);
         }
     }
 
diff --git a/ydb/core/metering/metering.cpp b/ydb/core/metering/metering.cpp
index 598de386922..d385f0bdd45 100644
--- a/ydb/core/metering/metering.cpp
+++ b/ydb/core/metering/metering.cpp
@@ -104,7 +104,7 @@ void TMeteringWriteActor::HandleUnexpectedEvent(STFUNC_SIG)
 
     LOG_W("TMeteringWriteActor:"
           << " unhandled event type: " << ev->GetTypeRewrite()
-          << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+          << " event: " << ev->ToString());
 }
 
 }   // namespace
diff --git a/ydb/core/mind/address_classification/net_classifier_ut.cpp b/ydb/core/mind/address_classification/net_classifier_ut.cpp
index 80654535755..3d7e280e6a6 100644
--- a/ydb/core/mind/address_classification/net_classifier_ut.cpp
+++ b/ydb/core/mind/address_classification/net_classifier_ut.cpp
@@ -47,7 +47,7 @@ static TAutoPtr<IEventHandle> GetClassifierUpdate(TServer& server, const TActorI
     auto& actorSystem = *server.GetRuntime();
 
     actorSystem.Send(
-        new IEventHandle(MakeNetClassifierID(), sender,
+        new IEventHandleFat(MakeNetClassifierID(), sender,
             new TEvNetClassifier::TEvSubscribe()
     ));
 
@@ -168,11 +168,11 @@ Y_UNIT_TEST_SUITE(TNetClassifierTest) {
         NActors::TActorId proxyId = actorSystem.Register(proxy);
 
         actorSystem.Send(
-            new NActors::IEventHandle(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(netDataSourcePort)), 0, true
+            new NActors::IEventHandleFat(proxyId, TActorId(), new NHttp::TEvHttpProxy::TEvAddListeningPort(netDataSourcePort)), 0, true
         );
 
         NActors::TActorId serverId = actorSystem.AllocateEdgeActor();
-        actorSystem.Send(new NActors::IEventHandle(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler(uri, serverId)), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(proxyId, serverId, new NHttp::TEvHttpProxy::TEvRegisterHandler(uri, serverId)), 0, true);
 
         const TActorId sender = cleverServer.GetRuntime()->AllocateEdgeActor();
 
@@ -184,7 +184,7 @@ Y_UNIT_TEST_SUITE(TNetClassifierTest) {
         NHttp::TEvHttpProxy::TEvHttpIncomingRequest* request = actorSystem.GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingRequest>(handle);
         UNIT_ASSERT_EQUAL(request->Request->URL, uri);
 
-        actorSystem.Send(new NActors::IEventHandle(handle->Sender, serverId, MakeHttpResponse(request, FormNetData())), 0, true);
+        actorSystem.Send(new NActors::IEventHandleFat(handle->Sender, serverId, MakeHttpResponse(request, FormNetData())), 0, true);
 
         // subscriber waits for proper net data update
         while (true) {
diff --git a/ydb/core/mind/bscontroller/bsc.cpp b/ydb/core/mind/bscontroller/bsc.cpp
index e19f9dd1cb5..0baaee3690b 100644
--- a/ydb/core/mind/bscontroller/bsc.cpp
+++ b/ydb/core/mind/bscontroller/bsc.cpp
@@ -176,16 +176,16 @@ void TBlobStorageController::Handle(TEvents::TEvPoisonPill::TPtr&) {
     Become(&TThis::StateBroken);
     for (TActorId *ptr : {&SelfHealId, &StatProcessorActorId, &SystemViewsCollectorId}) {
         if (const TActorId actorId = std::exchange(*ptr, {})) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
         }
     }
     for (const auto& [id, info] : GroupMap) {
         if (auto& actorId = info->VirtualGroupSetupMachineId) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
             actorId = {};
         }
     }
-    TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, Tablet(), SelfId(), nullptr, 0));
+    TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, Tablet(), SelfId(), nullptr, 0));
 }
 
 void TBlobStorageController::NotifyNodesAwaitingKeysForGroups(ui32 groupId) {
diff --git a/ydb/core/mind/bscontroller/config.cpp b/ydb/core/mind/bscontroller/config.cpp
index e41a2356b4f..1be709779ca 100644
--- a/ydb/core/mind/bscontroller/config.cpp
+++ b/ydb/core/mind/bscontroller/config.cpp
@@ -31,7 +31,7 @@ namespace NKikimr::NBsController {
                         record.SetNodeID(nodeId);
                         record.SetInstanceId(Self->InstanceId);
                         record.SetAvailDomain(AppData()->DomainsInfo->GetDomainUidByTabletId(Self->TabletID()));
-                        outbox.push_back(std::make_unique<IEventHandle>(MakeBlobStorageNodeWardenID(nodeId),
+                        outbox.push_back(std::make_unique<IEventHandleFat>(MakeBlobStorageNodeWardenID(nodeId),
                             Self->SelfId(), event.Release()));
                     }
                 }
@@ -466,11 +466,11 @@ namespace NKikimr::NBsController {
             }
 
             if (ev->Created || ev->Deleted) {
-                state.Outbox.push_back(std::make_unique<IEventHandle>(StatProcessorActorId, SelfId(), ev.Release()));
+                state.Outbox.push_back(std::make_unique<IEventHandleFat>(StatProcessorActorId, SelfId(), ev.Release()));
             }
             if (sh->GroupsToUpdate) {
                 FillInSelfHealGroups(*sh, &state);
-                state.Outbox.push_back(std::make_unique<IEventHandle>(SelfHealId, SelfId(), sh.Release()));
+                state.Outbox.push_back(std::make_unique<IEventHandleFat>(SelfHealId, SelfId(), sh.Release()));
             }
         }
 
diff --git a/ydb/core/mind/bscontroller/config_cmd.cpp b/ydb/core/mind/bscontroller/config_cmd.cpp
index 0ff4a74bc57..f9461fe7dfe 100644
--- a/ydb/core/mind/bscontroller/config_cmd.cpp
+++ b/ydb/core/mind/bscontroller/config_cmd.cpp
@@ -340,7 +340,7 @@ namespace NKikimr::NBsController {
                     STLOG(PRI_INFO, BS_CONTROLLER_AUDIT, BSCA09, "Transaction complete", (UniqueId, state->UniqueId));
                     state->ApplyConfigUpdates();
                 }
-                TActivationContext::Send(new IEventHandle(NotifyId, Self->SelfId(), Ev.Release(), 0, Cookie));
+                TActivationContext::Send(new IEventHandleFat(NotifyId, Self->SelfId(), Ev.Release(), 0, Cookie));
                 Self->UpdatePDisksCounters();
             }
         };
diff --git a/ydb/core/mind/bscontroller/get_group.cpp b/ydb/core/mind/bscontroller/get_group.cpp
index 78b5d28bcaa..cc509243aa3 100644
--- a/ydb/core/mind/bscontroller/get_group.cpp
+++ b/ydb/core/mind/bscontroller/get_group.cpp
@@ -27,7 +27,7 @@ public:
         auto res = std::make_unique<TEvBlobStorage::TEvControllerNodeServiceSetUpdate>(NKikimrProto::OK, nodeId);
         Self->ReadGroups(groupIDsToRead, true, res.get(), nodeId);
 
-        Response = std::make_unique<IEventHandle>(nodeId ? MakeBlobStorageNodeWardenID(nodeId) : Request->Sender,
+        Response = std::make_unique<IEventHandleFat>(nodeId ? MakeBlobStorageNodeWardenID(nodeId) : Request->Sender,
             Self->SelfId(), res.release());
 
         return true;
diff --git a/ydb/core/mind/bscontroller/group_metrics_exchange.cpp b/ydb/core/mind/bscontroller/group_metrics_exchange.cpp
index cc7b0239a25..da274d171f1 100644
--- a/ydb/core/mind/bscontroller/group_metrics_exchange.cpp
+++ b/ydb/core/mind/bscontroller/group_metrics_exchange.cpp
@@ -3,7 +3,7 @@
 namespace NKikimr::NBsController {
 
     class TBlobStorageController::TTxGroupMetricsExchange : public TTransactionBase<TBlobStorageController> {
-        std::unique_ptr<TEventHandle<TEvBlobStorage::TEvControllerGroupMetricsExchange>> Ev;
+        std::unique_ptr<TEventHandleFat<TEvBlobStorage::TEvControllerGroupMetricsExchange>> Ev;
         std::unique_ptr<TEvBlobStorage::TEvControllerGroupMetricsExchange> Response;
 
     public:
@@ -20,7 +20,7 @@ namespace NKikimr::NBsController {
             STLOG(PRI_DEBUG, BS_CONTROLLER, BSCTXGME00, "TTxGroupMetricsExchange::Execute", (Record, record));
 
             NIceDb::TNiceDb db(txc.DB);
-            
+
             for (NKikimrBlobStorage::TGroupMetrics& item : *record.MutableGroupMetrics()) {
                 if (TGroupInfo *group = Self->FindGroup(item.GetGroupId())) {
                     group->GroupMetrics = std::move(item);
diff --git a/ydb/core/mind/bscontroller/group_reconfigure_wipe.cpp b/ydb/core/mind/bscontroller/group_reconfigure_wipe.cpp
index 9a7aff6c7fd..8464828dceb 100644
--- a/ydb/core/mind/bscontroller/group_reconfigure_wipe.cpp
+++ b/ydb/core/mind/bscontroller/group_reconfigure_wipe.cpp
@@ -72,7 +72,7 @@ public:
                 const auto& node = nodeId;
                 const auto& record = msg->Record;
                 STLOG(PRI_DEBUG, BS_CONTROLLER, BSCTXGRW07, "Sending update", (NodeId, node), (Message, record));
-                TActivationContext::Send(new IEventHandle(MakeBlobStorageNodeWardenID(nodeId), Self->SelfId(), msg.Release()));
+                TActivationContext::Send(new IEventHandleFat(MakeBlobStorageNodeWardenID(nodeId), Self->SelfId(), msg.Release()));
             }
         }
 
@@ -81,7 +81,7 @@ public:
         auto& record = Event->Get()->Record;
         STLOG(Status == NKikimrProto::OK ? PRI_DEBUG : PRI_ERROR, BS_CONTROLLER, BSCTXGRW06, "TTxGroupReconfigureWipe complete",
             (Status, Status), (Request, record), (Response, response->Record));
-        TActivationContext::Send(new IEventHandle(Event->Sender, Self->SelfId(), response.Release(), 0, Event->Cookie));
+        TActivationContext::Send(new IEventHandleFat(Event->Sender, Self->SelfId(), response.Release(), 0, Event->Cookie));
     }
 };
 
diff --git a/ydb/core/mind/bscontroller/impl.h b/ydb/core/mind/bscontroller/impl.h
index 340f9ad725c..46e068df855 100644
--- a/ydb/core/mind/bscontroller/impl.h
+++ b/ydb/core/mind/bscontroller/impl.h
@@ -1611,12 +1611,12 @@ private:
         }
         for (TActorId *ptr : {&SelfHealId, &StatProcessorActorId, &SystemViewsCollectorId}) {
             if (const TActorId actorId = std::exchange(*ptr, {})) {
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
             }
         }
         for (const auto& [id, info] : GroupMap) {
             if (const auto& actorId = info->VirtualGroupSetupMachineId) {
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, actorId, SelfId(), nullptr, 0));
             }
         }
         return TActor::PassAway();
@@ -1657,7 +1657,7 @@ private:
     void Enqueue(STFUNC_SIG) override {
         Y_UNUSED(ctx);
         STLOG(PRI_DEBUG, BS_CONTROLLER, BSC04, "Enqueue", (TabletID, TabletID()), (Type, ev->GetTypeRewrite()),
-            (Event, ev->HasEvent() ? ev->GetBase()->ToString() : "serialized"));
+            (Event, ev->ToString()));
         InitQueue.push_back(ev);
     }
 
@@ -1809,7 +1809,7 @@ public:
 
     STFUNC(StateInit) {
         STLOG(PRI_DEBUG, BS_CONTROLLER, BSC05, "StateInit event", (Type, ev->GetTypeRewrite()),
-            (Event, ev->HasEvent() ? ev->GetBase()->ToString() : "serialized"));
+            (Event, ev->ToString()));
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvInterconnect::TEvNodesInfo, Handle);
             default:
@@ -1830,7 +1830,7 @@ public:
     }
 
     void PushProcessIncomingEvent() {
-        TActivationContext::Send(new IEventHandle(TEvPrivate::EvProcessIncomingEvent, 0, SelfId(), {}, nullptr, 0));
+        TActivationContext::Send(new IEventHandleFat(TEvPrivate::EvProcessIncomingEvent, 0, SelfId(), {}, nullptr, 0));
     }
 
     void ProcessIncomingEvent() {
@@ -1920,7 +1920,7 @@ public:
             default:
                 if (!HandleDefaultEvents(ev, ctx)) {
                     STLOG(PRI_ERROR, BS_CONTROLLER, BSC06, "StateWork unexpected event", (Type, type),
-                        (Event, ev->HasEvent() ? ev->GetBase()->ToString() : "serialized"));
+                        (Event, ev->ToString()));
                 }
             break;
         }
@@ -1942,7 +1942,7 @@ public:
         while (!InitQueue.empty()) {
             TAutoPtr<IEventHandle> &ev = InitQueue.front();
             STLOG(PRI_DEBUG, BS_CONTROLLER, BSC08, "Dequeue", (TabletID, TabletID()), (Type, ev->GetTypeRewrite()),
-                (Event, ev->HasEvent() ? ev->GetBase()->ToString() : "serialized"));
+                (Event, ev->ToString()));
             TActivationContext::Send(ev.Release());
             InitQueue.pop_front();
         }
diff --git a/ydb/core/mind/bscontroller/init_scheme.cpp b/ydb/core/mind/bscontroller/init_scheme.cpp
index 0a7779a131d..091b13bfd5b 100644
--- a/ydb/core/mind/bscontroller/init_scheme.cpp
+++ b/ydb/core/mind/bscontroller/init_scheme.cpp
@@ -39,7 +39,7 @@ public:
 
     void Complete(const TActorContext&) override {
         if (Failed) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, Self->SelfId(), {}, {}, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, Self->SelfId(), {}, {}, 0));
         } else {
             STLOG(PRI_DEBUG, BS_CONTROLLER, BSCTXIS03, "TTxInitScheme Complete");
             Self->Execute(Self->CreateTxMigrate());
diff --git a/ydb/core/mind/bscontroller/monitoring.cpp b/ydb/core/mind/bscontroller/monitoring.cpp
index 0de768c0906..11a07212ad5 100644
--- a/ydb/core/mind/bscontroller/monitoring.cpp
+++ b/ydb/core/mind/bscontroller/monitoring.cpp
@@ -60,7 +60,7 @@ public:
         }
         TStringStream str;
         RenderOperationLog(str, count, offset);
-        TActivationContext::Send(new IEventHandle(RespondTo, Self->SelfId(), new NMon::TEvRemoteHttpInfoRes(str.Str())));
+        TActivationContext::Send(new IEventHandleFat(RespondTo, Self->SelfId(), new NMon::TEvRemoteHttpInfoRes(str.Str())));
         return true;
     }
 
@@ -210,7 +210,7 @@ public:
         }
         TStringStream str;
         RenderOperationLogEntry(str);
-        TActivationContext::Send(new IEventHandle(RespondTo, Self->SelfId(), new NMon::TEvRemoteHttpInfoRes(str.Str())));
+        TActivationContext::Send(new IEventHandleFat(RespondTo, Self->SelfId(), new NMon::TEvRemoteHttpInfoRes(str.Str())));
         return true;
     }
 
@@ -516,7 +516,7 @@ public:
     }
 
     void Complete(const TActorContext&) override {
-        TActivationContext::Send(new IEventHandle(RespondTo, Self->SelfId(), Json
+        TActivationContext::Send(new IEventHandleFat(RespondTo, Self->SelfId(), Json
             ? static_cast<IEventBase*>(new NMon::TEvRemoteJsonInfoRes(GenerateJson()))
             : static_cast<IEventBase*>(new NMon::TEvRemoteHttpInfoRes(GenerateHtml()))));
     }
@@ -660,7 +660,7 @@ public:
     void Complete(const TActorContext&) override {
         STLOG(PRI_DEBUG, BS_CONTROLLER, BSCTXMO01, "TBlobStorageController::TTxMonEvent_SetDown",
             (GroupId, GroupId), (Down, Down), (Persist, Persist), (Response, Response));
-        TActivationContext::Send(new IEventHandle(Source, Self->SelfId(), new NMon::TEvRemoteJsonInfoRes(Response)));
+        TActivationContext::Send(new IEventHandleFat(Source, Self->SelfId(), new NMon::TEvRemoteJsonInfoRes(Response)));
     }
 };
 
@@ -711,7 +711,7 @@ public:
     void Complete(const TActorContext&) override {
         STLOG(PRI_DEBUG, BS_CONTROLLER, BSCTXMO02, "TBlobStorageController::TTxMonEvent_GetDown", (GroupId, GroupId),
             (Response, Response));
-        TActivationContext::Send(new IEventHandle(Source, Self->SelfId(), new NMon::TEvRemoteJsonInfoRes(Response)));
+        TActivationContext::Send(new IEventHandleFat(Source, Self->SelfId(), new NMon::TEvRemoteJsonInfoRes(Response)));
     }
 };
 
@@ -847,7 +847,7 @@ void TBlobStorageController::ProcessPostQuery(const NActorsProto::TRemoteHttpInf
             };
 
             const TActorId& processorId = Register(new TQueryExecActor(sender, accept));
-            TActivationContext::Send(new IEventHandle(SelfId(), processorId, request.release()));
+            TActivationContext::Send(new IEventHandleFat(SelfId(), processorId, request.release()));
         }
     }
 }
@@ -893,7 +893,7 @@ bool TBlobStorageController::OnRenderAppHtmlPage(NMon::TEvRemoteHttpInfo::TPtr e
                 Register(new TDisableSelfHealActor(ev->Sender, TStringBuilder() << "?TabletID="
                     << TabletID() << "&page=SelfHeal"));
             } else {
-                TActivationContext::Send(new IEventHandle(SelfHealId, ev->Sender, ev->Release().Release(), 0,
+                TActivationContext::Send(new IEventHandleFat(SelfHealId, ev->Sender, ev->Release().Release(), 0,
                     SelfHealEnable));
             }
             return true;
diff --git a/ydb/core/mind/bscontroller/register_node.cpp b/ydb/core/mind/bscontroller/register_node.cpp
index 6719464e217..d048549f73e 100644
--- a/ydb/core/mind/bscontroller/register_node.cpp
+++ b/ydb/core/mind/bscontroller/register_node.cpp
@@ -183,7 +183,7 @@ public:
         result->Record.SetInstanceId(Self->InstanceId);
         result->Record.SetComprehensive(false);
         result->Record.SetAvailDomain(AppData()->DomainsInfo->GetDomainUidByTabletId(Self->TabletID()));
-        Response = std::make_unique<IEventHandle>(MakeBlobStorageNodeWardenID(nodeId), Self->SelfId(), result.release(), 0, 0);
+        Response = std::make_unique<IEventHandleFat>(MakeBlobStorageNodeWardenID(nodeId), Self->SelfId(), result.release(), 0, 0);
 
         TString error;
         if (!updateIsSuccessful || (State->Changed() && !Self->CommitConfigUpdates(*State, false, false, false, txc, &error))) {
@@ -308,7 +308,7 @@ public:
         res->Record.SetInstanceId(Self->InstanceId);
         res->Record.SetComprehensive(true);
         res->Record.SetAvailDomain(AppData()->DomainsInfo->GetDomainUidByTabletId(Self->TabletID()));
-        Response = std::make_unique<IEventHandle>(request->Sender, Self->SelfId(), res.release(), 0, request->Cookie);
+        Response = std::make_unique<IEventHandleFat>(request->Sender, Self->SelfId(), res.release(), 0, request->Cookie);
 
         NIceDb::TNiceDb db(txc.DB);
         auto& node = Self->GetNode(nodeId);
diff --git a/ydb/core/mind/bscontroller/request_controller_info.cpp b/ydb/core/mind/bscontroller/request_controller_info.cpp
index 7f2952f8bb8..b87506995e8 100644
--- a/ydb/core/mind/bscontroller/request_controller_info.cpp
+++ b/ydb/core/mind/bscontroller/request_controller_info.cpp
@@ -51,7 +51,7 @@ public:
             }
         }
 
-        Response = std::make_unique<IEventHandle>(request->Sender, Self->SelfId(), response.release());
+        Response = std::make_unique<IEventHandleFat>(request->Sender, Self->SelfId(), response.release());
         return true;
     }
 
diff --git a/ydb/core/mind/bscontroller/scrub.cpp b/ydb/core/mind/bscontroller/scrub.cpp
index 4bf46624dff..9558cb20f11 100644
--- a/ydb/core/mind/bscontroller/scrub.cpp
+++ b/ydb/core/mind/bscontroller/scrub.cpp
@@ -593,7 +593,7 @@ public:
         auto ev = std::make_unique<TEvBlobStorage::TEvControllerScrubStartQuantum>(scrub->VSlotId.NodeId,
             scrub->VSlotId.PDiskId, scrub->VSlotId.VSlotId, scrub->State);
         STLOG(PRI_DEBUG, BS_CONTROLLER, BSC13, "sending TEvControllerScrubStartQuantum", (Msg, ev->ToString()));
-        TActivationContext::Send(new IEventHandle(MakeBlobStorageNodeWardenID(scrub->VSlotId.NodeId), Self->SelfId(),
+        TActivationContext::Send(new IEventHandleFat(MakeBlobStorageNodeWardenID(scrub->VSlotId.NodeId), Self->SelfId(),
             ev.release(), 0, scrub->Cookie));
         SetInProgress(scrub);
         if (!scrub->State) { // scrubbing has just started for this disk
@@ -777,7 +777,7 @@ TBlobStorageController::TScrubState::~TScrubState()
 
 void TBlobStorageController::TScrubState::HandleTimer() {
     Impl->OnTimer(TActivationContext::Now());
-    TActivationContext::Schedule(TDuration::Minutes(1), new IEventHandle(Impl->SelfId(), {}, new TEvPrivate::TEvScrub));
+    TActivationContext::Schedule(TDuration::Minutes(1), new IEventHandleFat(Impl->SelfId(), {}, new TEvPrivate::TEvScrub));
 }
 
 void TBlobStorageController::TScrubState::AddItem(TVSlotId vslotId, std::optional<TString> state,
diff --git a/ydb/core/mind/bscontroller/select_groups.cpp b/ydb/core/mind/bscontroller/select_groups.cpp
index e88d2b33e43..064b8d55930 100644
--- a/ydb/core/mind/bscontroller/select_groups.cpp
+++ b/ydb/core/mind/bscontroller/select_groups.cpp
@@ -68,7 +68,7 @@ public:
             Self->ProcessSelectGroupsQueueItem(it);
         } else {
             STLOG(PRI_DEBUG, BS_CONTROLLER, BSCTXSG04, "TEvControllerSelectGroups finished", (Result, result->Record));
-            Response = std::make_unique<IEventHandle>(request->Sender, Self->SelfId(), result.Release(), 0, request->Cookie);
+            Response = std::make_unique<IEventHandleFat>(request->Sender, Self->SelfId(), result.Release(), 0, request->Cookie);
 
             const TDuration passed = TDuration::Seconds(timer.Passed());
             Self->TabletCounters->Percentile()[NBlobStorageController::COUNTER_PERCENTILE_SELECT_GROUPS].IncrementFor(passed.MicroSeconds());
diff --git a/ydb/core/mind/bscontroller/storage_stats_calculator.cpp b/ydb/core/mind/bscontroller/storage_stats_calculator.cpp
index 5100a024e9b..baa531114c6 100644
--- a/ydb/core/mind/bscontroller/storage_stats_calculator.cpp
+++ b/ydb/core/mind/bscontroller/storage_stats_calculator.cpp
@@ -208,7 +208,7 @@ public:
 
 private:
     void Yield() {
-        Send(new IEventHandle(EvResume, 0, SelfActorId, {}, nullptr, 0));
+        Send(new IEventHandleFat(EvResume, 0, SelfActorId, {}, nullptr, 0));
         WaitForSpecificEvent([](IEventHandle& ev) { return ev.Type == EvResume; });
     }
 
diff --git a/ydb/core/mind/bscontroller/sys_view.cpp b/ydb/core/mind/bscontroller/sys_view.cpp
index 6c41cedf346..0b63bcdf647 100644
--- a/ydb/core/mind/bscontroller/sys_view.cpp
+++ b/ydb/core/mind/bscontroller/sys_view.cpp
@@ -133,7 +133,7 @@ public:
 
     void PassAway() override {
         if (StorageStatsCalculatorId) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, StorageStatsCalculatorId, {}, nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, StorageStatsCalculatorId, {}, nullptr, 0));
         }
 
         TActorBootstrapped::PassAway();
@@ -288,7 +288,7 @@ IActor* TBlobStorageController::CreateSystemViewsCollector() {
 }
 
 void TBlobStorageController::ForwardToSystemViewsCollector(STATEFN_SIG) {
-    TActivationContext::Send(ev->Forward(SystemViewsCollectorId));
+    TActivationContext::Forward(ev, SystemViewsCollectorId);
 }
 
 void TBlobStorageController::Handle(TEvPrivate::TEvUpdateSystemViews::TPtr&) {
diff --git a/ydb/core/mind/bscontroller/ut_bscontroller/main.cpp b/ydb/core/mind/bscontroller/ut_bscontroller/main.cpp
index cee71cfa675..a599be43033 100644
--- a/ydb/core/mind/bscontroller/ut_bscontroller/main.cpp
+++ b/ydb/core/mind/bscontroller/ut_bscontroller/main.cpp
@@ -120,7 +120,7 @@ struct TEnvironmentSetup {
 
     TVector<std::tuple<TString, i32, ui32>> GetNodes() {
         const TActorId edge = Runtime->AllocateEdgeActor();
-        Runtime->Send(new IEventHandle(GetNameserviceActorId(), edge, new TEvInterconnect::TEvListNodes));
+        Runtime->Send(new IEventHandleFat(GetNameserviceActorId(), edge, new TEvInterconnect::TEvListNodes));
         auto response = Runtime->GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(edge);
         TVector<std::tuple<TString, i32, ui32>> res;
         for (const auto& nodeInfo : response->Get()->Nodes) {
diff --git a/ydb/core/mind/bscontroller/ut_selfheal/env.h b/ydb/core/mind/bscontroller/ut_selfheal/env.h
index 197ab4b4f76..33ab9b0a7d4 100644
--- a/ydb/core/mind/bscontroller/ut_selfheal/env.h
+++ b/ydb/core/mind/bscontroller/ut_selfheal/env.h
@@ -52,11 +52,11 @@ struct TEnvironmentSetup {
     }
 
     template<typename TEvent>
-    TAutoPtr<TEventHandle<TEvent>> WaitForEdgeActorEvent(const TActorId& actorId, bool termOnCapture = true) {
+    TAutoPtr<TEventHandleFat<TEvent>> WaitForEdgeActorEvent(const TActorId& actorId, bool termOnCapture = true) {
         for (;;) {
             auto ev = Runtime->WaitForEdgeActorEvent({actorId});
             if (ev->GetTypeRewrite() == TEvent::EventType) {
-                TAutoPtr<TEventHandle<TEvent>> res = reinterpret_cast<TEventHandle<TEvent>*>(ev.release());
+                TAutoPtr<TEventHandleFat<TEvent>> res = reinterpret_cast<TEventHandleFat<TEvent>*>(ev.release());
                 if (termOnCapture) {
                     Runtime->DestroyActor(actorId);
                 }
@@ -76,7 +76,7 @@ struct TEnvironmentSetup {
 
     std::map<ui32, std::tuple<TString, i32>> GetNodeMap() {
         const TActorId edge = Runtime->AllocateEdgeActor(NodeId);
-        Runtime->Send(new IEventHandle(GetNameserviceActorId(), edge, new TEvInterconnect::TEvListNodes), NodeId);
+        Runtime->Send(new IEventHandleFat(GetNameserviceActorId(), edge, new TEvInterconnect::TEvListNodes), NodeId);
         auto response = WaitForEdgeActorEvent<TEvInterconnect::TEvNodesInfo>(edge);
         std::map<ui32, std::tuple<TString, i32>> res;
         for (const auto& nodeInfo : response->Get()->Nodes) {
@@ -199,7 +199,7 @@ struct TEnvironmentSetup {
         for (ui32 nodeId : Runtime->GetNodes()) {
             const TActorId wardenId = MakeBlobStorageNodeWardenID(nodeId);
             const TActorId edge = Runtime->AllocateEdgeActor(nodeId);
-            Runtime->Send(new IEventHandle(wardenId, edge, new TEvCheckState(EState::CONNECTED)), nodeId);
+            Runtime->Send(new IEventHandleFat(wardenId, edge, new TEvCheckState(EState::CONNECTED)), nodeId);
             edges.push_back(edge);
         }
         for (TActorId edge : edges) {
@@ -210,7 +210,7 @@ struct TEnvironmentSetup {
 
     void Wait(TDuration timeout) {
         const TActorId edge = Runtime->AllocateEdgeActor(NodeId);
-        Runtime->Send(new IEventHandle(TimerActor, edge, new TEvArmTimer(timeout)), NodeId);
+        Runtime->Send(new IEventHandleFat(TimerActor, edge, new TEvArmTimer(timeout)), NodeId);
         WaitForEdgeActorEvent<TEvents::TEvWakeup>(edge);
     }
 
diff --git a/ydb/core/mind/bscontroller/ut_selfheal/self_heal_actor_ut.cpp b/ydb/core/mind/bscontroller/ut_selfheal/self_heal_actor_ut.cpp
index 07da54d7a3a..2bb0cddf02a 100644
--- a/ydb/core/mind/bscontroller/ut_selfheal/self_heal_actor_ut.cpp
+++ b/ydb/core/mind/bscontroller/ut_selfheal/self_heal_actor_ut.cpp
@@ -90,7 +90,7 @@ Y_UNIT_TEST_SUITE(SelfHealActorTest) {
             RegisterDiskResponders(runtime, info);
             auto ev = std::make_unique<TEvControllerUpdateSelfHealInfo>();
             ev->GroupsToUpdate[info->GroupID] = Convert(info, {0}, {E::ERROR});
-            runtime.Send(new IEventHandle(selfHealId, parentId, ev.release()), 1);
+            runtime.Send(new IEventHandleFat(selfHealId, parentId, ev.release()), 1);
             ValidateCmd(parentId, runtime, 0, 1, 0, 0, 0);
         });
     }
@@ -101,8 +101,8 @@ Y_UNIT_TEST_SUITE(SelfHealActorTest) {
             RegisterDiskResponders(runtime, info);
             auto ev = std::make_unique<TEvControllerUpdateSelfHealInfo>();
             ev->GroupsToUpdate[info->GroupID] = Convert(info, {0}, {E::ERROR, E::REPLICATING});
-            runtime.Send(new IEventHandle(selfHealId, parentId, ev.release()), 1);
-            runtime.Schedule(TDuration::Minutes(30), new IEventHandle(TEvents::TSystem::Wakeup, 0, parentId, {}, nullptr, 0), nullptr, 1);
+            runtime.Send(new IEventHandleFat(selfHealId, parentId, ev.release()), 1);
+            runtime.Schedule(TDuration::Minutes(30), new IEventHandleFat(TEvents::TSystem::Wakeup, 0, parentId, {}, nullptr, 0), nullptr, 1);
             auto res = runtime.WaitForEdgeActorEvent({parentId});
             UNIT_ASSERT_EQUAL(res->GetTypeRewrite(), TEvents::TSystem::Wakeup);
         });
diff --git a/ydb/core/mind/bscontroller/ut_selfheal/timer_actor.h b/ydb/core/mind/bscontroller/ut_selfheal/timer_actor.h
index 2bbf215c7a1..8a7c40cc889 100644
--- a/ydb/core/mind/bscontroller/ut_selfheal/timer_actor.h
+++ b/ydb/core/mind/bscontroller/ut_selfheal/timer_actor.h
@@ -16,7 +16,7 @@ struct TEvTimer : TEventLocal<TEvTimer, EvTimer> {
     std::unique_ptr<IEventHandle> HitEvent;
 
     TEvTimer(const IEventHandle& ev)
-        : HitEvent(new IEventHandle(TEvents::TSystem::Wakeup, 0, ev.Sender, TActorId(), {}, ev.Cookie))
+        : HitEvent(new IEventHandleFat(TEvents::TSystem::Wakeup, 0, ev.Sender, TActorId(), {}, ev.Cookie))
     {}
 
     void Hit() {
diff --git a/ydb/core/mind/bscontroller/ut_selfheal/vdisk_mock.h b/ydb/core/mind/bscontroller/ut_selfheal/vdisk_mock.h
index dddd4728ac1..46189bb89de 100644
--- a/ydb/core/mind/bscontroller/ut_selfheal/vdisk_mock.h
+++ b/ydb/core/mind/bscontroller/ut_selfheal/vdisk_mock.h
@@ -52,7 +52,7 @@ public:
     }
 
     void StopActor() {
-        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, GetActorId(), {}, {}, 0));
+        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, GetActorId(), {}, {}, 0));
         LOG_DEBUG(*TlsActivationContext, NKikimrServices::BS_NODE, "[%u] VDiskId# %s destroyed", NodeId, VDiskId.ToString().data());
     }
 
diff --git a/ydb/core/mind/bscontroller/virtual_group.cpp b/ydb/core/mind/bscontroller/virtual_group.cpp
index f093eff1b6d..bfd195ed39b 100644
--- a/ydb/core/mind/bscontroller/virtual_group.cpp
+++ b/ydb/core/mind/bscontroller/virtual_group.cpp
@@ -223,7 +223,7 @@ namespace NKikimr::NBsController {
                 if (State) {
                     State->ApplyConfigUpdates();
                 }
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Bootstrap, 0, Machine->SelfId(), {}, nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Bootstrap, 0, Machine->SelfId(), {}, nullptr, 0));
             }
         };
 
@@ -550,7 +550,7 @@ namespace NKikimr::NBsController {
                 if (ErrorReason) {
                     ev->Record.SetErrorReason(ErrorReason);
                 }
-                auto reply = std::make_unique<IEventHandle>(Ev->Sender, Self->SelfId(), ev.release(), 0, Ev->Cookie);
+                auto reply = std::make_unique<IEventHandleFat>(Ev->Sender, Self->SelfId(), ev.release(), 0, Ev->Cookie);
                 if (Ev->InterconnectSession) {
                     reply->Rewrite(TEvInterconnect::EvForward, Ev->InterconnectSession);
                 }
diff --git a/ydb/core/mind/hive/hive.h b/ydb/core/mind/hive/hive.h
index 9ff14466249..258b5c6d21e 100644
--- a/ydb/core/mind/hive/hive.h
+++ b/ydb/core/mind/hive/hive.h
@@ -90,12 +90,12 @@ struct TCompleteNotifications {
 
     void Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0) {
         Y_VERIFY(!!SelfID);
-        Notifications.emplace_back(new IEventHandle(recipient, SelfID, ev, flags, cookie), TDuration());
+        Notifications.emplace_back(new IEventHandleFat(recipient, SelfID, ev, flags, cookie), TDuration());
     }
 
     void Schedule(TDuration duration, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0) {
         Y_VERIFY(!!SelfID);
-        Notifications.emplace_back(new IEventHandle(SelfID, {}, ev, flags, cookie), duration);
+        Notifications.emplace_back(new IEventHandleFat(SelfID, {}, ev, flags, cookie), duration);
     }
 
     size_t size() const {
diff --git a/ydb/core/mind/hive/hive_impl.cpp b/ydb/core/mind/hive/hive_impl.cpp
index a0063e4e020..7b374f60e85 100644
--- a/ydb/core/mind/hive/hive_impl.cpp
+++ b/ydb/core/mind/hive/hive_impl.cpp
@@ -479,7 +479,7 @@ void THive::Handle(TEvPrivate::TEvBootTablets::TPtr&) {
             BLOG_I("Primary(Sub)DomainKey is not set, setting it from TTabletStorageInfo::TenantPathId to " << Info()->TenantPathId);
 
             auto msg = MakeHolder<TEvHive::TEvConfigureHive>(TSubDomainKey(Info()->TenantPathId.OwnerId, Info()->TenantPathId.LocalPathId));
-            TEvHive::TEvConfigureHive::TPtr event((TEventHandle<TEvHive::TEvConfigureHive>*) new IEventHandle(
+            TEvHive::TEvConfigureHive::TPtr event((TEventHandleFat<TEvHive::TEvConfigureHive>*) new IEventHandleFat(
                 TActorId(), TActorId(), msg.Release()
             ));
             Execute(CreateConfigureSubdomain(event));
@@ -2371,7 +2371,7 @@ void THive::Handle(TEvHive::TEvInvalidateStoragePools::TPtr& ev) {
         }
     }
 
-    auto reply = std::make_unique<IEventHandle>(TEvHive::EvInvalidateStoragePoolsReply, 0, ev->Sender, SelfId(), nullptr, ev->Cookie);
+    auto reply = std::make_unique<IEventHandleFat>(TEvHive::EvInvalidateStoragePoolsReply, 0, ev->Sender, SelfId(), nullptr, ev->Cookie);
     if (ev->InterconnectSession) {
         reply->Rewrite(TEvInterconnect::EvForward, ev->InterconnectSession);
     }
@@ -2381,7 +2381,7 @@ void THive::Handle(TEvHive::TEvInvalidateStoragePools::TPtr& ev) {
 void THive::Handle(TEvHive::TEvReassignOnDecommitGroup::TPtr& ev) {
     const ui32 groupId = ev->Get()->Record.GetGroupId();
     BLOG_D("THive::Handle(TEvReassignOnDecommitGroup) GroupId# " << groupId);
-    auto reply = std::make_unique<IEventHandle>(TEvHive::EvReassignOnDecommitGroupReply, 0, ev->Sender, SelfId(), nullptr, ev->Cookie);
+    auto reply = std::make_unique<IEventHandleFat>(TEvHive::EvReassignOnDecommitGroupReply, 0, ev->Sender, SelfId(), nullptr, ev->Cookie);
     if (ev->InterconnectSession) {
         reply->Rewrite(TEvInterconnect::EvForward, ev->InterconnectSession);
     }
@@ -2505,7 +2505,7 @@ STFUNC(THive::StateWork) {
     default:
         if (!HandleDefaultEvents(ev, ctx)) {
             BLOG_W("THive::StateWork unhandled event type: " << ev->GetTypeRewrite()
-                   << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                   << " event: " << ev->ToString());
         }
         break;
     }
diff --git a/ydb/core/mind/hive/hive_ut.cpp b/ydb/core/mind/hive/hive_ut.cpp
index bfb85a59d38..6328f591b2c 100644
--- a/ydb/core/mind/hive/hive_ut.cpp
+++ b/ydb/core/mind/hive/hive_ut.cpp
@@ -59,7 +59,7 @@ namespace {
 
     void SetupLogging(TTestActorRuntime& runtime) {
         NActors::NLog::EPriority priority = ENABLE_DETAILED_HIVE_LOG ? NLog::PRI_DEBUG : NLog::PRI_ERROR;
-        NActors::NLog::EPriority otherPriority = NLog::PRI_ERROR;
+        NActors::NLog::EPriority otherPriority = NLog::PRI_DEBUG;
 
         if (ENABLE_DETAILED_HIVE_LOG) {
             runtime.SetLogPriority(NKikimrServices::HIVE, NLog::PRI_TRACE);
@@ -316,7 +316,7 @@ namespace {
         NTabletPipe::TClientConfig pipeConfig;
         pipeConfig.RetryPolicy = NTabletPipe::TClientRetryPolicy::WithRetries();
 
-        runtime.Send(new IEventHandle(GetNameserviceActorId(), sender, new TEvInterconnect::TEvListNodes));
+        runtime.Send(new IEventHandleFat(GetNameserviceActorId(), sender, new TEvInterconnect::TEvListNodes));
         TAutoPtr<IEventHandle> handleNodesInfo;
         auto nodesInfo = runtime.GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(handleNodesInfo);
 
@@ -429,7 +429,7 @@ void FormatPDiskForTest(TString path, ui64 diskSize, ui32 chunkSize, ui64 guid,
     EntropyPool().Read(&sysLogKey, sizeof(NKikimr::NPDisk::TKey));
 
     NKikimr::FormatPDisk(path, diskSize, 4 << 10, chunkSize, guid,
-        chunkKey, logKey, sysLogKey, NPDisk::YdbDefaultPDiskSequence, "", false, false, sectorMap, 
+        chunkKey, logKey, sysLogKey, NPDisk::YdbDefaultPDiskSequence, "", false, false, sectorMap,
         false);
 }
 
@@ -505,7 +505,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
 
     void SendToLocal(TTestActorRuntime &runtime, ui32 nodeIndex, IEventBase* event) {
         TActorId local = MakeLocalID(runtime.GetNodeId(nodeIndex));
-        runtime.Send(new IEventHandle(local, TActorId(), event), nodeIndex);
+        runtime.Send(new IEventHandleFat(local, TActorId(), event), nodeIndex);
     }
 
     void SendKillLocal(TTestActorRuntime &runtime, ui32 nodeIndex) {
@@ -955,7 +955,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
         {
             TAutoPtr<IEventHandle> handle;
             TActorId whiteboard = NNodeWhiteboard::MakeNodeWhiteboardServiceId(nodeId);
-            runtime.Send(new IEventHandle(whiteboard, senderA, new NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest()));
+            runtime.Send(new IEventHandleFat(whiteboard, senderA, new NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest()));
             NNodeWhiteboard::TEvWhiteboard::TEvTabletStateResponse* wbResponse = runtime.GrabEdgeEventRethrow<NNodeWhiteboard::TEvWhiteboard::TEvTabletStateResponse>(handle);
             for (const NKikimrWhiteboard::TTabletStateInfo& tabletInfo : wbResponse->Record.GetTabletStateInfo()) {
                 if (tablets.count(tabletInfo.GetTabletId()) == 0) {
@@ -2279,7 +2279,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
         WaitForTabletIsUp(runtime, tabletId, 0, &pipeConfig);
         runtime.SendToPipe(hiveTablet, sender, new TEvInterconnect::TEvNodeDisconnected(runtime.GetNodeId(0)));
         //TActorId local = MakeLocalID(runtime.GetNodeId(0));
-        //runtime.Send(new IEventHandle(local, sender, new TEvTabletPipe::TEvClientDestroyed(hiveTablet, TActorId(), TActorId())), 0);
+        //runtime.Send(new IEventHandleFat(local, sender, new TEvTabletPipe::TEvClientDestroyed(hiveTablet, TActorId(), TActorId())), 0);
         SendKillLocal(runtime, 0);
         runtime.Register(CreateTabletKiller(hiveTablet));
         {
@@ -2869,7 +2869,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
         TActorId senderA = runtime.AllocateEdgeActor();
         for (int i = 0; i < NODES; ++i) {
             TActorId whiteboard = NNodeWhiteboard::MakeNodeWhiteboardServiceId(runtime.GetNodeId(i));
-            runtime.Send(new IEventHandle(whiteboard, senderA, new NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest()));
+            runtime.Send(new IEventHandleFat(whiteboard, senderA, new NNodeWhiteboard::TEvWhiteboard::TEvTabletStateRequest()));
             TAutoPtr<IEventHandle> handle;
             NNodeWhiteboard::TEvWhiteboard::TEvTabletStateResponse* response = runtime.GrabEdgeEventRethrow<NNodeWhiteboard::TEvWhiteboard::TEvTabletStateResponse>(handle);
             for (const NKikimrWhiteboard::TTabletStateInfo& tabletInfo : response->Record.GetTabletStateInfo()) {
@@ -4557,7 +4557,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
 
         TActorId disconnecter = runtime.AllocateEdgeActor(0);
         TActorId proxy = runtime.GetInterconnectProxy(0, 1);
-        runtime.Send(new IEventHandle(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
+        runtime.Send(new IEventHandleFat(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
 
         // Tablet should boot when the locking node disconnects
         WaitForTabletIsUp(runtime, tabletId, 0);
@@ -4602,7 +4602,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
 
         TActorId disconnecter = runtime.AllocateEdgeActor(0);
         TActorId proxy = runtime.GetInterconnectProxy(0, 1);
-        runtime.Send(new IEventHandle(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
+        runtime.Send(new IEventHandleFat(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
 
         // Tablet should boot when timeout expires
         WaitForTabletIsUp(runtime, tabletId, 0);
@@ -4740,7 +4740,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
             }
         } while (TInstant::Now() <= deadline);
 
-        runtime.Send(new IEventHandle(pipeClient, TActorId(), new TEvents::TEvPoisonPill()));
+        runtime.Send(new IEventHandleFat(pipeClient, TActorId(), new TEvents::TEvPoisonPill()));
         UNIT_ASSERT_C(!res, "Unexpected successful tablet connection");
     }
 
@@ -4766,7 +4766,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
         // disconnect the node
         TActorId disconnecter = runtime.AllocateEdgeActor(0);
         TActorId proxy = runtime.GetInterconnectProxy(0, 1);
-        runtime.Send(new IEventHandle(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
+        runtime.Send(new IEventHandleFat(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
 
         // reconnect the lock
         SendLockTabletExecution(runtime, hiveTablet, tabletId, 1, NKikimrProto::OK, owner, 500, true);
@@ -4821,7 +4821,7 @@ Y_UNIT_TEST_SUITE(THiveTest) {
         // disconnect the node
         TActorId disconnecter = runtime.AllocateEdgeActor(0);
         TActorId proxy = runtime.GetInterconnectProxy(0, 1);
-        runtime.Send(new IEventHandle(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
+        runtime.Send(new IEventHandleFat(proxy, disconnecter, new TEvInterconnect::TEvDisconnect()), 0);
 
         // wait for the lost lock notification
         VerifyLockTabletExecutionLost(runtime, tabletId, owner);
diff --git a/ydb/core/mind/hive/monitoring.cpp b/ydb/core/mind/hive/monitoring.cpp
index 3afccc647f3..ef4c54ee721 100644
--- a/ydb/core/mind/hive/monitoring.cpp
+++ b/ydb/core/mind/hive/monitoring.cpp
@@ -2471,7 +2471,7 @@ public:
             Self->SubActors.emplace_back(waitActor);
         }
         // TODO: pass arguments as post data json
-        ctx.Send(new IEventHandle(Self->SelfId(), waitActorId, new TEvHive::TEvInitMigration()));
+        ctx.Send(new IEventHandleFat(Self->SelfId(), waitActorId, new TEvHive::TEvInitMigration()));
         return true;
     }
 
@@ -2543,7 +2543,7 @@ public:
         waitActor = new TQueryMigrationWaitActor(Source, Self);
         waitActorId = ctx.RegisterWithSameMailbox(waitActor);
         Self->SubActors.emplace_back(waitActor);
-        ctx.Send(new IEventHandle(Self->SelfId(), waitActorId, new TEvHive::TEvQueryMigration()));
+        ctx.Send(new IEventHandleFat(Self->SelfId(), waitActorId, new TEvHive::TEvQueryMigration()));
         return true;
     }
 
diff --git a/ydb/core/mind/hive/tx__process_pending_operations.cpp b/ydb/core/mind/hive/tx__process_pending_operations.cpp
index e817b450f5f..150e9de6d64 100644
--- a/ydb/core/mind/hive/tx__process_pending_operations.cpp
+++ b/ydb/core/mind/hive/tx__process_pending_operations.cpp
@@ -18,10 +18,10 @@ public:
             THolder<TEvHive::TEvCreateTablet> evCreateTablet(new TEvHive::TEvCreateTablet());
             evCreateTablet->Record = pendingCreateTablet.CreateTablet;
             BLOG_D("THive::TTxProcessPendingOperations(): retry CreateTablet");
-            TlsActivationContext->Send(new IEventHandle(Self->SelfId(), pendingCreateTablet.Sender, evCreateTablet.Release(), 0, pendingCreateTablet.Cookie));
+            TlsActivationContext->Send(new IEventHandleFat(Self->SelfId(), pendingCreateTablet.Sender, evCreateTablet.Release(), 0, pendingCreateTablet.Cookie));
         }
         for (auto& handle : Self->PendingOperations) {
-            TlsActivationContext->Send(handle);
+            TlsActivationContext->Send(handle.Release());
         }
         Self->PendingOperations.clear();
         return true;
diff --git a/ydb/core/mind/labels_maintainer.cpp b/ydb/core/mind/labels_maintainer.cpp
index 36f1cb379a5..1823c67e1c0 100644
--- a/ydb/core/mind/labels_maintainer.cpp
+++ b/ydb/core/mind/labels_maintainer.cpp
@@ -38,7 +38,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/mind/lease_holder.cpp b/ydb/core/mind/lease_holder.cpp
index 5d47d04c71f..77e5545dff4 100644
--- a/ydb/core/mind/lease_holder.cpp
+++ b/ydb/core/mind/lease_holder.cpp
@@ -72,7 +72,7 @@ private:
 
         default:
             Y_FAIL("TLeaseHolder::StateIdle unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
@@ -87,7 +87,7 @@ private:
 
         default:
             Y_FAIL("TLeaseHolder::StatePing unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/mind/local.cpp b/ydb/core/mind/local.cpp
index 011a9939b57..6f53e42b433 100644
--- a/ydb/core/mind/local.cpp
+++ b/ydb/core/mind/local.cpp
@@ -952,7 +952,7 @@ public:
             CFunc(TEvents::TSystem::PoisonPill, HandlePoison);
             default:
                 LOG_DEBUG(ctx, NKikimrServices::LOCAL, "TLocalNodeRegistrar: Unhandled in StateWork type: %" PRIx32
-                    " event: %s", ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                    " event: %s", ev->GetTypeRewrite(), ev->ToString().data());
                 break;
         }
     }
@@ -1452,8 +1452,7 @@ public:
             auto actor = new TDomainLocal(domainsInfo, *domain, Config);
             DomainLocals[domainName] = ctx.Register(actor);
         }
-
-        ctx.Send(ev->Forward(DomainLocals[domainName]));
+        ctx.Forward(ev, DomainLocals[domainName]);
         return true;
     }
 
@@ -1518,7 +1517,7 @@ public:
         default:
             LOG_DEBUG_S(ctx, NKikimrServices::LOCAL,
                         "TLocal: Unhandled in StateResolveSubDomain type: " <<  ev->GetTypeRewrite() <<
-                        " event: " << ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                        " event: " << ev->ToString());
             break;
         }
     }
diff --git a/ydb/core/mind/node_broker.cpp b/ydb/core/mind/node_broker.cpp
index ca7aa9cbc52..822e9a66b85 100644
--- a/ydb/core/mind/node_broker.cpp
+++ b/ydb/core/mind/node_broker.cpp
@@ -76,7 +76,7 @@ void TNodeBroker::Enqueue(TAutoPtr<IEventHandle> &ev,
     case TEvNodeBroker::EvResolveNode:
     case TEvNodeBroker::EvRegistrationRequest:
         EnqueuedEvents.push_back(ev);
-        [[fallthrough]]; // AUTOGENERATED_FALLTHROUGH_FIXME
+        break;
     default:
         TTabletExecutedFlat::Enqueue(ev, ctx);
     }
@@ -274,7 +274,7 @@ void TNodeBroker::ScheduleEpochUpdate(const TActorContext &ctx)
     if (now >= Epoch.End) {
         ctx.Schedule(TDuration::Zero(), new TEvPrivate::TEvUpdateEpoch);
     } else {
-        auto *ev = new IEventHandle(SelfId(), SelfId(), new TEvPrivate::TEvUpdateEpoch);
+        auto *ev = new IEventHandleFat(SelfId(), SelfId(), new TEvPrivate::TEvUpdateEpoch);
         EpochTimerCookieHolder.Reset(ISchedulerCookie::Make2Way());
         CreateLongTimer(ctx, Epoch.End - now, ev, AppData(ctx)->SystemPoolId,
                         EpochTimerCookieHolder.Get());
@@ -284,10 +284,10 @@ void TNodeBroker::ScheduleEpochUpdate(const TActorContext &ctx)
     }
 }
 
-void TNodeBroker::ProcessEnqueuedEvents(const TActorContext &ctx)
+void TNodeBroker::ProcessEnqueuedEvents(const TActorContext&)
 {
     for (auto &ev : EnqueuedEvents)
-        Receive(ev, ctx);
+        Receive(ev);
     EnqueuedEvents.clear();
 }
 
diff --git a/ydb/core/mind/node_broker__update_config.cpp b/ydb/core/mind/node_broker__update_config.cpp
index d741cefae54..5cb2ede3d03 100644
--- a/ydb/core/mind/node_broker__update_config.cpp
+++ b/ydb/core/mind/node_broker__update_config.cpp
@@ -39,7 +39,7 @@ public:
         }
 
         auto resp = MakeHolder<TEvConsole::TEvConfigNotificationResponse>(rec);
-        Response = new IEventHandle(Notification->Sender, Self->SelfId(), resp.Release(),
+        Response = new IEventHandleFat(Notification->Sender, Self->SelfId(), resp.Release(),
                                     0, Notification->Cookie);
 
         return true;
@@ -54,7 +54,7 @@ public:
 
         auto resp = MakeHolder<TEvNodeBroker::TEvSetConfigResponse>();
         resp->Record.MutableStatus()->SetCode(NKikimrNodeBroker::TStatus::OK);
-        Response = new IEventHandle(Request->Sender, Self->SelfId(), resp.Release(),
+        Response = new IEventHandleFat(Request->Sender, Self->SelfId(), resp.Release(),
                                     0, Request->Cookie);
 
         return true;
@@ -85,7 +85,7 @@ public:
 
         if (Response) {
             LOG_TRACE_S(ctx, NKikimrServices::NODE_BROKER,
-                        "TTxUpdateConfig reply with: " << Response->GetBase()->ToString());
+                        "TTxUpdateConfig reply with: " << Response->ToString());
             ctx.Send(Response);
         }
 
diff --git a/ydb/core/mind/node_broker_impl.h b/ydb/core/mind/node_broker_impl.h
index 212e84c5cff..be3f77cb77b 100644
--- a/ydb/core/mind/node_broker_impl.h
+++ b/ydb/core/mind/node_broker_impl.h
@@ -159,7 +159,7 @@ private:
     STFUNC(StateInit)
     {
         LOG_DEBUG(ctx, NKikimrServices::NODE_BROKER, "StateInit event type: %" PRIx32 " event: %s",
-                  ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                  ev->GetTypeRewrite(), ev->ToString().data());
         StateInitImpl(ev, ctx);
     }
 
@@ -183,7 +183,7 @@ private:
         default:
             if (!HandleDefaultEvents(ev, ctx)) {
                 Y_FAIL("TNodeBroker::StateWork unexpected event type: %" PRIx32 " event: %s from %s",
-                       ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?",
+                       ev->GetTypeRewrite(), ev->ToString().data(),
                        ev->Sender.ToString().data());
             }
         }
diff --git a/ydb/core/mind/node_broker_ut.cpp b/ydb/core/mind/node_broker_ut.cpp
index 7d171f43adc..546d319f193 100644
--- a/ydb/core/mind/node_broker_ut.cpp
+++ b/ydb/core/mind/node_broker_ut.cpp
@@ -206,7 +206,7 @@ void Setup(TTestActorRuntime& runtime,
 
     auto scheduledFilter = [](TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& event, TDuration delay, TInstant& deadline) {
         if (event->HasEvent()
-            && (dynamic_cast<TDynamicNameserver::TEvPrivate::TEvUpdateEpoch*>(event->GetBase())))
+            && event->Type == TDynamicNameserver::TEvPrivate::TEvUpdateEpoch::EventType)
             return false;
         return TTestActorRuntime::DefaultScheduledFilterFunc(runtime, event, delay, deadline);
     };
@@ -314,7 +314,7 @@ NKikimrNodeBroker::TEpoch WaitForEpochUpdate(TTestActorRuntime &runtime,
         struct TIsEvUpdateEpoch {
             bool operator()(IEventHandle &ev) {
                 if (ev.HasEvent()
-                    && (dynamic_cast<TNodeBroker::TEvPrivate::TEvUpdateEpoch*>(ev.GetBase())))
+                    && ev.Type == TNodeBroker::TEvPrivate::TEvUpdateEpoch::EventType)
                     return true;
                 return false;
             }
@@ -499,7 +499,7 @@ void CheckResolveNode(TTestActorRuntime &runtime,
                       const TString &addr)
 {
     TAutoPtr<TEvInterconnect::TEvResolveNode> event = new TEvInterconnect::TEvResolveNode(nodeId);
-    runtime.Send(new IEventHandle(GetNameserviceActorId(), sender, event.Release()));
+    runtime.Send(new IEventHandleFat(GetNameserviceActorId(), sender, event.Release()));
 
     TAutoPtr<IEventHandle> handle;
     auto reply = runtime.GrabEdgeEventRethrow<TEvLocalNodeInfo>(handle);
@@ -514,7 +514,7 @@ void CheckResolveUnknownNode(TTestActorRuntime &runtime,
                              ui32 nodeId)
 {
     TAutoPtr<TEvInterconnect::TEvResolveNode> event = new TEvInterconnect::TEvResolveNode(nodeId);
-    runtime.Send(new IEventHandle(GetNameserviceActorId(), sender, event.Release()));
+    runtime.Send(new IEventHandleFat(GetNameserviceActorId(), sender, event.Release()));
 
     TAutoPtr<IEventHandle> handle;
     auto reply = runtime.GrabEdgeEventRethrow<TEvLocalNodeInfo>(handle);
@@ -531,7 +531,7 @@ void GetNameserverNodesList(TTestActorRuntime &runtime,
 {
     ui32 maxStaticNodeId = runtime.GetAppData().DynamicNameserviceConfig->MaxStaticNodeId;
     TAutoPtr<TEvInterconnect::TEvListNodes> event = new TEvInterconnect::TEvListNodes;
-    runtime.Send(new IEventHandle(GetNameserviceActorId(), sender, event.Release()));
+    runtime.Send(new IEventHandleFat(GetNameserviceActorId(), sender, event.Release()));
 
     TAutoPtr<IEventHandle> handle;
     auto reply = runtime.GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(handle);
@@ -608,7 +608,7 @@ void CheckGetNode(TTestActorRuntime &runtime,
                   bool exists)
 {
     TAutoPtr<TEvInterconnect::TEvGetNode> event = new TEvInterconnect::TEvGetNode(nodeId);
-    runtime.Send(new IEventHandle(GetNameserviceActorId(), sender, event.Release()));
+    runtime.Send(new IEventHandleFat(GetNameserviceActorId(), sender, event.Release()));
 
     TAutoPtr<IEventHandle> handle;
     auto reply = runtime.GrabEdgeEventRethrow<TEvInterconnect::TEvNodeInfo>(handle);
@@ -1126,7 +1126,7 @@ Y_UNIT_TEST_SUITE(TDynamicNameserverTest) {
         struct TIsEvUpdateEpoch {
             bool operator()(IEventHandle &ev) {
                 if (ev.HasEvent()
-                    && (dynamic_cast<TDynamicNameserver::TEvPrivate::TEvUpdateEpoch*>(ev.GetBase())))
+                    && (dynamic_cast<TDynamicNameserver::TEvPrivate::TEvUpdateEpoch*>(ev.StaticCastAsLocal<IEventBase>())))
                     return true;
                 return false;
             }
diff --git a/ydb/core/mind/tenant_node_enumeration_ut.cpp b/ydb/core/mind/tenant_node_enumeration_ut.cpp
index f8c7a505c29..e1511ca7c4e 100644
--- a/ydb/core/mind/tenant_node_enumeration_ut.cpp
+++ b/ydb/core/mind/tenant_node_enumeration_ut.cpp
@@ -13,7 +13,7 @@ void CheckAddTenant(TTenantTestRuntime &runtime, const TString &tenant, TEvLocal
     limit.SetCPU(cpu);
     limit.SetMemory(memory);
     limit.SetNetwork(network);
-    runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+    runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                   runtime.Sender,
                                   new TEvLocal::TEvAddTenant(tenant, limit)));
     TAutoPtr<IEventHandle> handle;
diff --git a/ydb/core/mind/tenant_pool.cpp b/ydb/core/mind/tenant_pool.cpp
index 8aa3aacf319..7490a04b2c6 100644
--- a/ydb/core/mind/tenant_pool.cpp
+++ b/ydb/core/mind/tenant_pool.cpp
@@ -668,7 +668,7 @@ public:
         if (!ev)
             return "no event";
         return Sprintf("%" PRIx32 " event %s", ev->GetTypeRewrite(),
-                       ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized");
+                       ev->ToString().data());
     }
 
     void Handle(NMon::TEvHttpInfo::TPtr &ev, const TActorContext &ctx)
@@ -733,7 +733,7 @@ public:
 
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
@@ -809,12 +809,12 @@ public:
 
     void Handle(TEvents::TEvSubscribe::TPtr &ev, const TActorContext &ctx) {
         for (auto &pr : DomainTenantPools)
-            ctx.Send(new IEventHandle(pr.second, ev->Sender, new TEvents::TEvSubscribe()));
+            ctx.Send(new IEventHandleFat(pr.second, ev->Sender, new TEvents::TEvSubscribe()));
     }
 
     void Handle(TEvents::TEvUnsubscribe::TPtr &ev, const TActorContext &ctx) {
         for (auto &pr : DomainTenantPools)
-            ctx.Send(new IEventHandle(pr.second, ev->Sender, new TEvents::TEvUnsubscribe()));
+            ctx.Send(new IEventHandleFat(pr.second, ev->Sender, new TEvents::TEvUnsubscribe()));
     }
 
     void Handle(TEvLocal::TEvLocalDrainNode::TPtr &ev, const TActorContext &ctx) {
@@ -872,7 +872,7 @@ public:
             HFunc(TEvLocal::TEvLocalDrainNode, Handle);
         default:
             Y_FAIL("unexpected event type: %" PRIx32 " event: %s",
-                   ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->GetTypeRewrite(), ev->ToString().data());
             break;
         }
     }
diff --git a/ydb/core/mind/tenant_slot_broker.cpp b/ydb/core/mind/tenant_slot_broker.cpp
index 65f7a86328b..e4a54490949 100644
--- a/ydb/core/mind/tenant_slot_broker.cpp
+++ b/ydb/core/mind/tenant_slot_broker.cpp
@@ -445,7 +445,7 @@ void TTenantSlotBroker::Enqueue(TAutoPtr<IEventHandle> &ev,
 {
     LOG_DEBUG(ctx, NKikimrServices::TENANT_SLOT_BROKER,
               "Enqueue: %" PRIu64 ", event type: %" PRIu32 " event: %s",
-              TabletID(), ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+              TabletID(), ev->GetTypeRewrite(), ev->ToString().data());
     InitQueue.push_back(ev);
 }
 
@@ -634,7 +634,7 @@ void TTenantSlotBroker::ProcessEnqueuedEvents(const TActorContext &ctx)
         TAutoPtr<IEventHandle> &ev = InitQueue.front();
         LOG_DEBUG(ctx, NKikimrServices::TENANT_SLOT_BROKER,
                   "Dequeue: %" PRIu64 ", event type: %" PRIu32 " event: %s",
-                  TabletID(), ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                  TabletID(), ev->GetTypeRewrite(), ev->ToString().data());
         ctx.ExecutorThread.Send(ev.Release());
         InitQueue.pop_front();
     }
diff --git a/ydb/core/mind/tenant_slot_broker_impl.h b/ydb/core/mind/tenant_slot_broker_impl.h
index ef08bb73b3f..5edd9efcdb4 100644
--- a/ydb/core/mind/tenant_slot_broker_impl.h
+++ b/ydb/core/mind/tenant_slot_broker_impl.h
@@ -1125,7 +1125,7 @@ private:
         default:
             if (!HandleDefaultEvents(ev, ctx)) {
                 Y_FAIL("TTenantSlotBroker::StateWork unexpected event type: %" PRIx32 " event: %s",
-                       ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                       ev->GetTypeRewrite(), ev->ToString().data());
             }
         }
     }
diff --git a/ydb/core/mind/tenant_ut_local.cpp b/ydb/core/mind/tenant_ut_local.cpp
index 5aab98212de..04168ada0b2 100644
--- a/ydb/core/mind/tenant_ut_local.cpp
+++ b/ydb/core/mind/tenant_ut_local.cpp
@@ -12,7 +12,7 @@ void CheckAddTenant(TTenantTestRuntime &runtime, const TString &tenant, TEvLocal
     limit.SetCPU(cpu);
     limit.SetMemory(memory);
     limit.SetNetwork(network);
-    runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+    runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                   runtime.Sender,
                                   new TEvLocal::TEvAddTenant(tenant, limit)));
     TAutoPtr<IEventHandle> handle;
@@ -41,7 +41,7 @@ void CheckAlterTenant(TTenantTestRuntime &runtime, const TString &tenant, TEvLoc
     limit.SetCPU(cpu);
     limit.SetMemory(memory);
     limit.SetNetwork(network);
-    runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+    runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                   runtime.Sender,
                                   new TEvLocal::TEvAlterTenant(tenant, limit)));
     TAutoPtr<IEventHandle> handle;
@@ -96,15 +96,15 @@ Y_UNIT_TEST_SUITE(TLocalTests) {
         limit.SetMemory(1);
         limit.SetNetwork(1);
 
-        runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+        runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                       runtime.Sender,
                                       new TEvLocal::TEvAddTenant(TENANT1_1_NAME, limit)));
         runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(handle);
 
-        runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+        runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                       runtime.Sender,
                                       new TEvLocal::TEvAddTenant(TENANT1_1_NAME, limit)));
-        runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+        runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                       runtime.Sender,
                                       new TEvLocal::TEvAddTenant(TENANT1_2_NAME, limit)));
         runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(handle);
@@ -140,17 +140,17 @@ Y_UNIT_TEST_SUITE(TLocalTests) {
         limit.SetMemory(1);
         limit.SetNetwork(1);
 
-        runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+        runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                       runtime.Sender,
                                       new TEvLocal::TEvAddTenant(TENANT1_1_NAME, limit)));
         runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(handle);
 
-        runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+        runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                       runtime.Sender,
                                       new TEvLocal::TEvAddTenant(TENANT1_2_NAME, limit)));
         runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(handle);
 
-        runtime.Send(new IEventHandle(MakeLocalID(runtime.GetNodeId(0)),
+        runtime.Send(new IEventHandleFat(MakeLocalID(runtime.GetNodeId(0)),
                                       runtime.Sender,
                                       new TEvLocal::TEvRemoveTenant(TENANT1_1_NAME)));
 
diff --git a/ydb/core/mind/tenant_ut_pool.cpp b/ydb/core/mind/tenant_ut_pool.cpp
index bd3dbc7fc0c..b411f3b74a7 100644
--- a/ydb/core/mind/tenant_ut_pool.cpp
+++ b/ydb/core/mind/tenant_ut_pool.cpp
@@ -325,11 +325,11 @@ Y_UNIT_TEST_SUITE(TTenantPoolTests) {
         runtime.CreateTenantPool(0);
 
         // Subscribe on root pool and wait until domain pool started
-        runtime.Send(new IEventHandle(tenantPoolRoot, sender, new TEvents::TEvSubscribe()));
+        runtime.Send(new IEventHandleFat(tenantPoolRoot, sender, new TEvents::TEvSubscribe()));
         checker(runtime.GrabEdgeEvent<TEvStatus>(sender), EState::TENANT_ASSIGNED);
 
         // Get status from domain pool
-        runtime.Send(new IEventHandle(tenantPool, sender, new TEvTenantPool::TEvGetStatus(true)));
+        runtime.Send(new IEventHandleFat(tenantPool, sender, new TEvTenantPool::TEvGetStatus(true)));
         checker(runtime.GrabEdgeEvent<TEvStatus>(sender), expected);
     }
 
diff --git a/ydb/core/mind/ut_fat/blobstorage_node_warden_ut_fat.cpp b/ydb/core/mind/ut_fat/blobstorage_node_warden_ut_fat.cpp
index a347ed3c3c9..ce71d65b290 100644
--- a/ydb/core/mind/ut_fat/blobstorage_node_warden_ut_fat.cpp
+++ b/ydb/core/mind/ut_fat/blobstorage_node_warden_ut_fat.cpp
@@ -83,7 +83,7 @@ void FormatPDisk(TString path, ui64 diskSize, ui32 chunkSize, ui64 guid, bool is
     }
 
     NKikimr::FormatPDisk(path, diskSize, 4 << 10, chunkSize, guid,
-        chunkKey, logKey, sysLogKey, NPDisk::YdbDefaultPDiskSequence, "Test", 
+        chunkKey, logKey, sysLogKey, NPDisk::YdbDefaultPDiskSequence, "Test",
         false, false, nullptr, false);
 }
 
@@ -318,7 +318,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         ui32 nodeId = sender.NodeId();
         TActorId nodeWarden = MakeBlobStorageNodeWardenID(nodeId);
         ui64 cookie = 6543210;
-        runtime.Send(new IEventHandle(proxy, sender,
+        runtime.Send(new IEventHandleFat(proxy, sender,
             new TEvBlobStorage::TEvPut(logoBlobId, data, TInstant::Max()),
             IEventHandle::FlagForwardOnNondelivery, cookie, &nodeWarden), sender.NodeId() - runtime.GetNodeId(0));
 
@@ -335,7 +335,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         ui32 nodeId = sender.NodeId();
         TActorId nodeWarden = MakeBlobStorageNodeWardenID(nodeId);
         ui64 cookie = 6543210;
-        runtime.Send(new IEventHandle(proxy, sender,
+        runtime.Send(new IEventHandleFat(proxy, sender,
             new TEvBlobStorage::TEvGet(logoBlobId, 0, 0, TInstant::Max(),
                 NKikimrBlobStorage::EGetHandleClass::LowRead),
             IEventHandle::FlagForwardOnNondelivery, cookie, &nodeWarden), sender.NodeId() - runtime.GetNodeId(0));
@@ -367,7 +367,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
                 TEvBlobStorage::TEvVGet::EFlags::None,
                 cookie,
                 {id});
-        runtime.Send(new IEventHandle(vDiskActor, sender, x.release()), sender.NodeId() - runtime.GetNodeId(0));
+        runtime.Send(new IEventHandleFat(vDiskActor, sender, x.release()), sender.NodeId() - runtime.GetNodeId(0));
 
         TAutoPtr<IEventHandle> handle;
         auto vgetResult = runtime.GrabEdgeEventRethrow<TEvBlobStorage::TEvVGetResult>(handle);
@@ -402,7 +402,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
 
         // TODO: the proxy just should not be there, check that instead!
         TActorId proxy = MakeBlobStorageProxyID(groupId);
-        runtime.Send(new IEventHandle(proxy, sender1, new TEvents::TEvPoisonPill()), 1);
+        runtime.Send(new IEventHandleFat(proxy, sender1, new TEvents::TEvPoisonPill()), 1);
 
         Put(runtime, sender1, groupId, TLogoBlobID(100, 0, 1, 0, 3, 0), "yyy");
         Get(runtime, sender0, groupId, TLogoBlobID(100, 0, 1, 0, 3, 0), "yyy");
@@ -425,7 +425,7 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
 
         // TODO: the proxy just should not be there, check that instead!
         TActorId proxy = MakeBlobStorageProxyID(groupId);
-        runtime.Send(new IEventHandle(proxy, sender1, new TEvents::TEvPoisonPill()), 1);
+        runtime.Send(new IEventHandleFat(proxy, sender1, new TEvents::TEvPoisonPill()), 1);
 
         Put(runtime, sender1, groupId, TLogoBlobID(100, 0, 1, 0, 3, 0), "yyy");
         Get(runtime, sender1, groupId, TLogoBlobID(100, 0, 1, 0, 3, 0), "yyy");
diff --git a/ydb/core/mon/crossref.cpp b/ydb/core/mon/crossref.cpp
index af9ad30bdcf..8cc2bbb4b9f 100644
--- a/ydb/core/mon/crossref.cpp
+++ b/ydb/core/mon/crossref.cpp
@@ -43,7 +43,7 @@ public:
 
             const ui64 id = NextRequestId++;
             request.PendingIds.push_back(id);
-            TActivationContext::Schedule(ev->Get()->Deadline, new IEventHandle(NActors::TEvents::TSystem::Wakeup, 0, SelfId(), TActorId(), nullptr, id));
+            TActivationContext::Schedule(ev->Get()->Deadline, new IEventHandleFat(NActors::TEvents::TSystem::Wakeup, 0, SelfId(), TActorId(), nullptr, id));
             RequestsInProgress.emplace(id, ev);
         }
     }
diff --git a/ydb/core/mon/mon.cpp b/ydb/core/mon/mon.cpp
index b32266d9112..b409baf09ea 100644
--- a/ydb/core/mon/mon.cpp
+++ b/ydb/core/mon/mon.cpp
@@ -24,7 +24,7 @@ NActors::IEventHandle* TMon::DefaultAuthorizer(const NActors::TActorId& owner, N
     TStringBuf ydbSessionId = request.GetCookie("ydb_session_id");
     TStringBuf authorization = request.GetHeader("Authorization");
     if (!authorization.empty()) {
-        return new NActors::IEventHandle(
+        return new NActors::IEventHandleFat(
             NKikimr::MakeTicketParserID(),
             owner,
             new NKikimr::TEvTicketParser::TEvAuthorizeTicket({
@@ -33,7 +33,7 @@ NActors::IEventHandle* TMon::DefaultAuthorizer(const NActors::TActorId& owner, N
             IEventHandle::FlagTrackDelivery
         );
     } else if (!ydbSessionId.empty()) {
-        return new NActors::IEventHandle(
+        return new NActors::IEventHandleFat(
             NKikimr::MakeTicketParserID(),
             owner,
             new NKikimr::TEvTicketParser::TEvAuthorizeTicket({
@@ -42,7 +42,7 @@ NActors::IEventHandle* TMon::DefaultAuthorizer(const NActors::TActorId& owner, N
             IEventHandle::FlagTrackDelivery
         );
     } else if (NKikimr::AppData()->EnforceUserTokenRequirement && NKikimr::AppData()->DefaultUserSIDs.empty()) {
-        return new NActors::IEventHandle(
+        return new NActors::IEventHandleFat(
             owner,
             owner,
             new NKikimr::TEvTicketParser::TEvAuthorizeTicketResult(TString(), {
@@ -52,7 +52,7 @@ NActors::IEventHandle* TMon::DefaultAuthorizer(const NActors::TActorId& owner, N
         );
     } else if (!NKikimr::AppData()->DefaultUserSIDs.empty()) {
         TIntrusivePtr<NACLib::TUserToken> token = new NACLib::TUserToken(NKikimr::AppData()->DefaultUserSIDs);
-        return new NActors::IEventHandle(
+        return new NActors::IEventHandleFat(
             owner,
             owner,
             new NKikimr::TEvTicketParser::TEvAuthorizeTicketResult(TString(), token)
diff --git a/ydb/core/mon/mon_impl.h b/ydb/core/mon/mon_impl.h
index ab56828c764..eee67f0459e 100644
--- a/ydb/core/mon/mon_impl.h
+++ b/ydb/core/mon/mon_impl.h
@@ -215,7 +215,7 @@ public:
 
     virtual TAutoPtr<NActors::IEventHandle> AfterRegister(const NActors::TActorId &self, const TActorId& parentId) override {
         Y_UNUSED(parentId);
-        return new NActors::IEventHandle(self, self, new TEvents::TEvBootstrap(), 0);
+        return new NActors::IEventHandleFat(self, self, new TEvents::TEvBootstrap(), 0);
     }
 
 protected:
diff --git a/ydb/core/persqueue/mirrorer.cpp b/ydb/core/persqueue/mirrorer.cpp
index 047e801640b..000327f9b87 100644
--- a/ydb/core/persqueue/mirrorer.cpp
+++ b/ydb/core/persqueue/mirrorer.cpp
@@ -270,13 +270,13 @@ void TMirrorer::Handle(TEvPQ::TEvUpdateCounters::TPtr& /*ev*/, const TActorConte
             << "[STATE] wait new reader event=" << WaitNextReaderEventInFlight
             << ", last received event time=" << LastReadEventTime
             << ", read futures inflight  " << ReadFuturesInFlight << ", last id=" << ReadFeatureId);
-        if (!ReadFeatures.empty()) { 
+        if (!ReadFeatures.empty()) {
             const auto& oldest = *ReadFeatures.begin();
             const auto& info = oldest.second;
             LOG_NOTICE_S(ctx, NKikimrServices::PQ_MIRRORER, MirrorerDescription()
             << "[STATE] The oldest read future id=" << oldest.first
             << ", ts=" << info.first << " age=" << (ctx.Now() - info.first)
-            << ", future state: " << info.second.Initialized() 
+            << ", future state: " << info.second.Initialized()
             << "/" << info.second.HasValue() << "/" << info.second.HasException());
         }
     }
@@ -388,7 +388,7 @@ void TMirrorer::HandleInitCredentials(TEvPQ::TEvInitCredentials::TPtr& /*ev*/, c
             } else {
                 ev = MakeHolder<TEvPQ::TEvCredentialsCreated>(result.GetValue());
             }
-            actorSystem->Send(new NActors::IEventHandle(selfId, selfId, ev.Release()));
+            actorSystem->Send(new NActors::IEventHandleFat(selfId, selfId, ev.Release()));
         }
     );
     CredentialsRequestInFlight = true;
@@ -465,7 +465,7 @@ void TMirrorer::CreateConsumer(TEvPQ::TEvCreateConsumer::TPtr&, const TActorCont
         ScheduleConsumerCreation(ctx);
         return;
     }
-    
+
     LOG_NOTICE_S(ctx, NKikimrServices::PQ_MIRRORER, MirrorerDescription()
             << " read session created: " << ReadSession->GetSessionId());
 
@@ -556,11 +556,11 @@ void TMirrorer::StartWaitNextReaderEvent(const TActorContext& ctx) {
             selfId = SelfId(),
             futureId=futureId
         ](const NThreading::TFuture<void>&) {
-            actorSystem->Send(new NActors::IEventHandle(selfId, selfId, new TEvPQ::TEvReaderEventArrived(futureId)));
+            actorSystem->Send(new NActors::IEventHandleFat(selfId, selfId, new TEvPQ::TEvReaderEventArrived(futureId)));
         }
     );
-    
-    if (ReadFeatures.size() < MAX_READ_FUTURES_STORE) { 
+
+    if (ReadFeatures.size() < MAX_READ_FUTURES_STORE) {
         ReadFeatures[futureId] = {ctx.Now(), future};
     }
 }
@@ -578,7 +578,7 @@ void TMirrorer::DoProcessNextReaderEvent(const TActorContext& ctx, bool wakeup)
         return;
     }
     TMaybe<NYdb::NPersQueue::TReadSessionEvent::TEvent> event = ReadSession->GetEvent(false);
-    LOG_DEBUG_S(ctx, NKikimrServices::PQ_MIRRORER, MirrorerDescription() << " got next reader event: " << bool(event)); 
+    LOG_DEBUG_S(ctx, NKikimrServices::PQ_MIRRORER, MirrorerDescription() << " got next reader event: " << bool(event));
 
     if (wakeup && !event) {
         return;
diff --git a/ydb/core/persqueue/mirrorer.h b/ydb/core/persqueue/mirrorer.h
index 8c247147fa7..68f0b43777d 100644
--- a/ydb/core/persqueue/mirrorer.h
+++ b/ydb/core/persqueue/mirrorer.h
@@ -90,7 +90,7 @@ private:
 private:
     template<class TEvent>
     void ScheduleWithIncreasingTimeout(const TActorId& recipient, TDuration& timeout, const TDuration& maxTimeout, const TActorContext &ctx) {
-        ctx.ExecutorThread.ActorSystem->Schedule(timeout, new IEventHandle(recipient, SelfId(), new TEvent()));
+        ctx.ExecutorThread.ActorSystem->Schedule(timeout, new IEventHandleFat(recipient, SelfId(), new TEvent()));
         timeout = Min(timeout * 2, maxTimeout);
     }
 
diff --git a/ydb/core/persqueue/partition.h b/ydb/core/persqueue/partition.h
index 346cb5fdaa5..6bde9bde361 100644
--- a/ydb/core/persqueue/partition.h
+++ b/ydb/core/persqueue/partition.h
@@ -345,7 +345,7 @@ private:
     template <typename TEv>
     TString EventStr(const char * func, const TEv& ev) {
         TStringStream ss;
-        ss << func << " event# " << ev->GetTypeRewrite() << " (" << ev->GetBase()->ToStringHeader() << "), Tablet " << Tablet << ", Partition " << Partition
+        ss << func << " event# " << ev->GetTypeRewrite() << " (" << ev->GetTypeName() << "), Tablet " << Tablet << ", Partition " << Partition
            << ", Sender " << ev->Sender.ToString() << ", Recipient " << ev->Recipient.ToString() << ", Cookie: " << ev->Cookie;
         return ss.Str();
     }
diff --git a/ydb/core/persqueue/ut/counters_ut.cpp b/ydb/core/persqueue/ut/counters_ut.cpp
index 04aae14c11c..f95eec30c83 100644
--- a/ydb/core/persqueue/ut/counters_ut.cpp
+++ b/ydb/core/persqueue/ut/counters_ut.cpp
@@ -226,7 +226,7 @@ Y_UNIT_TEST(Partition) {
 
         THttpRequest httpReq(HTTP_METHOD_GET);
         NMonitoring::TMonService2HttpRequest monReq(nullptr, &httpReq, nullptr, nullptr, "", nullptr);
-        tc.Runtime->Send(new IEventHandle(aggregatorId, tc.Edge, new NMon::TEvHttpInfo(monReq)));
+        tc.Runtime->Send(new IEventHandleFat(aggregatorId, tc.Edge, new NMon::TEvHttpInfo(monReq)));
 
         TAutoPtr<IEventHandle> handle1;
         auto resp = tc.Runtime->GrabEdgeEvent<NMon::TEvHttpInfoRes>(handle1);
diff --git a/ydb/core/persqueue/ut/partition_ut.cpp b/ydb/core/persqueue/ut/partition_ut.cpp
index d941812800e..41532380681 100644
--- a/ydb/core/persqueue/ut/partition_ut.cpp
+++ b/ydb/core/persqueue/ut/partition_ut.cpp
@@ -348,7 +348,7 @@ void TPartitionFixture::SendCreateSession(ui64 cookie,
                                                      generation,
                                                      step,
                                                      TEvPQ::TEvSetClientInfo::ESCI_CREATE_SESSION);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::SendSetOffset(ui64 cookie,
@@ -362,7 +362,7 @@ void TPartitionFixture::SendSetOffset(ui64 cookie,
                                                      sessionId,
                                                      0,
                                                      0);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::SendGetOffset(ui64 cookie,
@@ -370,7 +370,7 @@ void TPartitionFixture::SendGetOffset(ui64 cookie,
 {
     auto event = MakeHolder<TEvPQ::TEvGetClientOffset>(cookie,
                                                        clientId);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitCmdWrite(const TCmdWriteMatcher& matcher)
@@ -470,7 +470,7 @@ void TPartitionFixture::SendCmdWriteResponse(NMsgBusProxy::EResponseStatus statu
     event->Record.SetStatus(status);
     event->Record.SetCookie(1); // SET_OFFSET_COOKIE
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitProxyResponse(const TProxyResponseMatcher& matcher)
@@ -543,7 +543,7 @@ void TPartitionFixture::SendConfigResponse(const TConfigParams& config)
         read->SetValue(out);
     }
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitDiskStatusRequest()
@@ -563,7 +563,7 @@ void TPartitionFixture::SendDiskStatusResponse()
     result->SetStatus(NKikimrProto::OK);
     result->SetStatusFlags(NKikimrBlobStorage::StatusIsValid);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitMetaReadRequest()
@@ -608,7 +608,7 @@ void TPartitionFixture::SendMetaReadResponse(TMaybe<ui64> step, TMaybe<ui64> txI
         read->SetStatus(NKikimrProto::NODATA);
     }
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitInfoRangeRequest()
@@ -653,7 +653,7 @@ void TPartitionFixture::SendInfoRangeResponse(ui32 partition,
         }
     }
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitDataRangeRequest()
@@ -680,7 +680,7 @@ void TPartitionFixture::SendDataRangeResponse(ui64 begin, ui64 end)
     //pair->SetValueSize();
     pair->SetCreationUnixTime(0);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::SendProposeTransactionRequest(ui32 partition,
@@ -703,7 +703,7 @@ void TPartitionFixture::SendProposeTransactionRequest(ui32 partition,
     body->SetImmediate(immediate);
     event->Record.SetTxId(txId);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitProposeTransactionResponse(const TProposeTransactionResponseMatcher& matcher)
@@ -731,7 +731,7 @@ void TPartitionFixture::SendCalcPredicate(ui64 step,
     auto event = MakeHolder<TEvPQ::TEvTxCalcPredicate>(step, txId);
     event->AddOperation(consumer, begin, end);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitCalcPredicateResult(const TCalcPredicateMatcher& matcher)
@@ -756,13 +756,13 @@ void TPartitionFixture::WaitCalcPredicateResult(const TCalcPredicateMatcher& mat
 void TPartitionFixture::SendCommitTx(ui64 step, ui64 txId)
 {
     auto event = MakeHolder<TEvPQ::TEvTxCommit>(step, txId);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::SendRollbackTx(ui64 step, ui64 txId)
 {
     auto event = MakeHolder<TEvPQ::TEvTxRollback>(step, txId);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitCommitTxDone(const TCommitTxDoneMatcher& matcher)
@@ -785,7 +785,7 @@ void TPartitionFixture::SendChangePartitionConfig(const TConfigParams& config)
 {
     auto event = MakeHolder<TEvPQ::TEvChangePartitionConfig>(TopicConverter, MakeConfig(config.Version,
                                                                                         config.Consumers));
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TPartitionFixture::WaitPartitionConfigChanged(const TChangePartitionConfigMatcher& matcher)
diff --git a/ydb/core/persqueue/ut/pq_ut.cpp b/ydb/core/persqueue/ut/pq_ut.cpp
index ec85e940c66..459f3778477 100644
--- a/ydb/core/persqueue/ut/pq_ut.cpp
+++ b/ydb/core/persqueue/ut/pq_ut.cpp
@@ -54,7 +54,7 @@ Y_UNIT_TEST(TestGroupsBalancer) {
     WaitPartition("session8", tc, 0, "session2", "topic1", pipe2);
     WaitPartition("", tc, 0, "", "", TActorId(), false);//no partitions to balance
 
-    tc.Runtime->Send(new IEventHandle(pipe2, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
+    tc.Runtime->Send(new IEventHandleFat(pipe2, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
 
     WaitPartition("session8", tc, 0, "", "", TActorId());
     WaitPartition("", tc, 0, "", "", TActorId(), false);//no partitions to balance
@@ -115,7 +115,7 @@ Y_UNIT_TEST(TestGroupsBalancer3) {
     WaitPartition("session", tc, 0, "", "", TActorId());
     WaitPartition("", tc, 0, "", "", TActorId(), false);//no partitions - return error
 
-    tc.Runtime->Send(new IEventHandle(pipe, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
+    tc.Runtime->Send(new IEventHandleFat(pipe, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
 
     TActorId pipe2 = RegisterReadSession("session1", tc);
     Y_UNUSED(pipe2);
@@ -294,7 +294,7 @@ Y_UNIT_TEST(TestCreateBalancer) {
 
         PQBalancerPrepare(TOPIC_NAME, {{1,{1,2}}, {2,{1,3}}}, ssId, tc);
 
-        tc.Runtime->Send(new IEventHandle(pipe1, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
+        tc.Runtime->Send(new IEventHandleFat(pipe1, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
 
 
 //        PQBalancerPrepare(TOPIC_NAME, {{2,1}}, tc); //TODO: not supported yet
@@ -311,7 +311,7 @@ Y_UNIT_TEST(TestCreateBalancer) {
         Y_UNUSED(pipe2);
         WaitPartition("session2", tc, 1, "session1", "topic1", pipe);
         WaitPartition("", tc, 0, "", "", TActorId(), false);//no partitions to balance
-        tc.Runtime->Send(new IEventHandle(pipe, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
+        tc.Runtime->Send(new IEventHandleFat(pipe, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and first session
 
         TDispatchOptions options;
         options.FinalEvents.push_back(TDispatchOptions::TFinalEventCondition(TEvTabletPipe::EvServerDisconnected));
@@ -585,7 +585,7 @@ Y_UNIT_TEST(TestWaitInOwners) {
 
         Y_VERIFY(!result); //no answer yet, waiting of dying of old ownership session
 
-        tc.Runtime->Send(new IEventHandle(newPipe, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and old session
+        tc.Runtime->Send(new IEventHandleFat(newPipe, tc.Edge, new TEvents::TEvPoisonPill()), 0, true); //will cause dying of pipe and old session
 
         TDispatchOptions options;
         options.FinalEvents.push_back(TDispatchOptions::TFinalEventCondition(TEvTabletPipe::EvServerDisconnected));
diff --git a/ydb/core/persqueue/ut/pqtablet_ut.cpp b/ydb/core/persqueue/ut/pqtablet_ut.cpp
index da7a4587f1f..773ef094ae2 100644
--- a/ydb/core/persqueue/ut/pqtablet_ut.cpp
+++ b/ydb/core/persqueue/ut/pqtablet_ut.cpp
@@ -412,7 +412,7 @@ void TPQTabletFixture::StartPQWriteStateObserver()
     FoundPQWriteState = false;
 
     auto observer = [this](TTestActorRuntimeBase&, TAutoPtr<IEventHandle>& event) {
-        if (auto* kvResponse = dynamic_cast<TEvKeyValue::TEvResponse*>(event->GetBase())) {
+        if (auto* kvResponse = event->CastAsLocal<TEvKeyValue::TEvResponse>()) {
             if ((event->Sender == event->Recipient) &&
                 kvResponse->Record.HasCookie() &&
                 (kvResponse->Record.GetCookie() == 4)) { // TPersQueue::WRITE_STATE_COOKIE
diff --git a/ydb/core/persqueue/ut/user_action_processor_ut.cpp b/ydb/core/persqueue/ut/user_action_processor_ut.cpp
index f041cbdf0b4..977a9f4b4a5 100644
--- a/ydb/core/persqueue/ut/user_action_processor_ut.cpp
+++ b/ydb/core/persqueue/ut/user_action_processor_ut.cpp
@@ -349,7 +349,7 @@ void TUserActionProcessorFixture::SendCreateSession(ui64 cookie,
                                                      generation,
                                                      step,
                                                      TEvPQ::TEvSetClientInfo::ESCI_CREATE_SESSION);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::SendSetOffset(ui64 cookie,
@@ -363,7 +363,7 @@ void TUserActionProcessorFixture::SendSetOffset(ui64 cookie,
                                                      sessionId,
                                                      0,
                                                      0);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::SendGetOffset(ui64 cookie,
@@ -371,7 +371,7 @@ void TUserActionProcessorFixture::SendGetOffset(ui64 cookie,
 {
     auto event = MakeHolder<TEvPQ::TEvGetClientOffset>(cookie,
                                                        clientId);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitCmdWrite(const TCmdWriteMatcher& matcher)
@@ -459,7 +459,7 @@ void TUserActionProcessorFixture::SendCmdWriteResponse(NMsgBusProxy::EResponseSt
     event->Record.SetStatus(status);
     event->Record.SetCookie(1); // SET_OFFSET_COOKIE
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitProxyResponse(const TProxyResponseMatcher& matcher)
@@ -523,7 +523,7 @@ void TUserActionProcessorFixture::SendDiskStatusResponse()
     result->SetStatus(NKikimrProto::OK);
     result->SetStatusFlags(NKikimrBlobStorage::StatusIsValid);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitMetaReadRequest()
@@ -568,7 +568,7 @@ void TUserActionProcessorFixture::SendMetaReadResponse(TMaybe<ui64> step, TMaybe
         read->SetStatus(NKikimrProto::NODATA);
     }
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitInfoRangeRequest()
@@ -613,7 +613,7 @@ void TUserActionProcessorFixture::SendInfoRangeResponse(ui32 partition,
         }
     }
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitDataRangeRequest()
@@ -640,7 +640,7 @@ void TUserActionProcessorFixture::SendDataRangeResponse(ui64 begin, ui64 end)
     //pair->SetValueSize();
     pair->SetCreationUnixTime(0);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::SendProposeTransactionRequest(ui32 partition,
@@ -663,7 +663,7 @@ void TUserActionProcessorFixture::SendProposeTransactionRequest(ui32 partition,
     body->SetImmediate(immediate);
     event->Record.SetTxId(txId);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::SendProposeTransactionRequest(const TProposeTransactionParams& params)
@@ -734,7 +734,7 @@ void TUserActionProcessorFixture::SendCalcPredicate(ui64 step,
     auto event = MakeHolder<TEvPQ::TEvTxCalcPredicate>(step, txId);
     event->AddOperation(consumer, begin, end);
 
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitCalcPredicateResult(const TCalcPredicateMatcher& matcher)
@@ -759,13 +759,13 @@ void TUserActionProcessorFixture::WaitCalcPredicateResult(const TCalcPredicateMa
 void TUserActionProcessorFixture::SendCommitTx(ui64 step, ui64 txId)
 {
     auto event = MakeHolder<TEvPQ::TEvTxCommit>(step, txId);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::SendRollbackTx(ui64 step, ui64 txId)
 {
     auto event = MakeHolder<TEvPQ::TEvTxRollback>(step, txId);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitCommitTxDone(const TCommitTxDoneMatcher& matcher)
@@ -796,7 +796,7 @@ void TUserActionProcessorFixture::SendChangePartitionConfig(const TVector<TCreat
     }
 
     auto event = MakeHolder<TEvPQ::TEvChangePartitionConfig>(TopicConverter, config);
-    Ctx->Runtime->SingleSys()->Send(new IEventHandle(ActorId, Ctx->Edge, event.Release()));
+    Ctx->Runtime->SingleSys()->Send(new IEventHandleFat(ActorId, Ctx->Edge, event.Release()));
 }
 
 void TUserActionProcessorFixture::WaitPartitionConfigChanged(const TChangePartitionConfigMatcher& matcher)
diff --git a/ydb/core/pgproxy/pg_connection.cpp b/ydb/core/pgproxy/pg_connection.cpp
index dbd2015ebcf..72e1bd9ae5a 100644
--- a/ydb/core/pgproxy/pg_connection.cpp
+++ b/ydb/core/pgproxy/pg_connection.cpp
@@ -438,24 +438,24 @@ protected:
         }
     };
 
-    template<typename TEv>
-    bool IsEventExpected(const TAutoPtr<TEventHandle<TEv>>& ev) {
+    template<typename TEvent>
+    bool IsEventExpected(const TAutoPtr<TEvent>& ev) {
         return (ev->Cookie == 0) || (ev->Cookie == OutgoingSequenceNumber);
     }
 
-    template<typename TEv>
-    void PostponeEvent(const TAutoPtr<TEventHandle<TEv>>& ev) {
-        TAutoPtr<IEventHandle> evb = ev.Release();
-        BLOG_D("Postpone event " << evb->Cookie);
+    template<typename TEvent>
+    void PostponeEvent(TAutoPtr<TEvent>& ev) {
+        BLOG_D("Postpone event " << ev->Cookie);
+        TAutoPtr<IEventHandle> evb(ev.Release());
         auto it = std::upper_bound(PostponedEvents.begin(), PostponedEvents.end(), evb, TEventsComparator());
         PostponedEvents.insert(it, evb);
     }
 
     void ReplayPostponedEvents() {
         if (!PostponedEvents.empty()) {
-            auto event = PostponedEvents.front();
+            TAutoPtr<IEventHandle> event = std::move(PostponedEvents.front());
             PostponedEvents.pop_front();
-            StateConnected(event, TActivationContext::AsActorContext());
+            StateConnected(event);
         }
     }
 
@@ -771,18 +771,17 @@ protected:
         return true;
     }
 
-    STATEFN(StateAccepting) {
+    LIGHTFN(StateAccepting) {
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvPollerReady, HandleAccepting);
             hFunc(TEvPollerRegisterResult, HandleAccepting);
         }
     }
 
-    STATEFN(StateConnected) {
+    LIGHTFN(StateConnected) {
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvPollerReady, HandleConnected);
             hFunc(TEvPollerRegisterResult, HandleConnected);
-
             hFunc(TEvPGEvents::TEvAuthResponse, HandleConnected);
             hFunc(TEvPGEvents::TEvQueryResponse, HandleConnected);
             hFunc(TEvPGEvents::TEvParseResponse, HandleConnected);
diff --git a/ydb/core/pgproxy/pg_proxy_events.h b/ydb/core/pgproxy/pg_proxy_events.h
index 7fdedffb944..d30ebe139c2 100644
--- a/ydb/core/pgproxy/pg_proxy_events.h
+++ b/ydb/core/pgproxy/pg_proxy_events.h
@@ -39,7 +39,7 @@ struct TEvPGEvents {
 
     using TDataRow = std::vector<TString>;
 
-    struct TEvConnectionOpened : NActors::TEventLocal<TEvConnectionOpened, EvConnectionOpened> {
+    struct TEvConnectionOpened : NActors::TEventLight<TEvConnectionOpened, EvConnectionOpened> {
         std::shared_ptr<TPGInitial> Message;
 
         TEvConnectionOpened(std::shared_ptr<TPGInitial> message)
@@ -47,10 +47,10 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvConnectionClosed : NActors::TEventLocal<TEvConnectionClosed, EvConnectionClosed> {
+    struct TEvConnectionClosed : NActors::TEventLight<TEvConnectionClosed, EvConnectionClosed> {
     };
 
-    struct TEvAuth : NActors::TEventLocal<TEvAuth, EvAuth> {
+    struct TEvAuth : NActors::TEventLight<TEvAuth, EvAuth> {
         std::shared_ptr<TPGInitial> InitialMessage;
         std::unique_ptr<TPGPasswordMessage> PasswordMessage;
 
@@ -64,7 +64,7 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvAuthResponse : NActors::TEventLocal<TEvAuthResponse, EvAuthResponse> {
+    struct TEvAuthResponse : NActors::TEventLight<TEvAuthResponse, EvAuthResponse> {
         TString Error;
     };
 
@@ -81,7 +81,7 @@ struct TEvPGEvents {
     // -> TEvQuery
     // <- TEvErrorResponse
 
-    struct TEvQuery : NActors::TEventLocal<TEvQuery, EvQuery> {
+    struct TEvQuery : NActors::TEventLight<TEvQuery, EvQuery> {
         std::unique_ptr<TPGQuery> Message;
 
         TEvQuery(std::unique_ptr<TPGQuery> message)
@@ -89,7 +89,7 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvQueryResponse : NActors::TEventLocal<TEvQueryResponse, EvQueryResponse> {
+    struct TEvQueryResponse : NActors::TEventLight<TEvQueryResponse, EvQueryResponse> {
         std::vector<TRowDescriptionField> DataFields;
         std::vector<TDataRow> DataRows;
         std::vector<std::pair<char, TString>> ErrorFields;
@@ -124,7 +124,7 @@ struct TEvPGEvents {
         R = "scanner_yyerror"
         */
 
-    struct TEvParseResponse : NActors::TEventLocal<TEvParseResponse, EvParseResponse> {
+    struct TEvParseResponse : NActors::TEventLight<TEvParseResponse, EvParseResponse> {
         std::unique_ptr<TPGParse> OriginalMessage;
 
         TEvParseResponse(std::unique_ptr<TPGParse> originalMessage)
@@ -132,7 +132,7 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvParse : NActors::TEventLocal<TEvParse, EvParse> {
+    struct TEvParse : NActors::TEventLight<TEvParse, EvParse> {
         std::unique_ptr<TPGParse> Message;
 
         TEvParse(std::unique_ptr<TPGParse> message)
@@ -144,7 +144,7 @@ struct TEvPGEvents {
         }
     };
 
-    struct TEvBindResponse : NActors::TEventLocal<TEvBindResponse, EvBindResponse> {
+    struct TEvBindResponse : NActors::TEventLight<TEvBindResponse, EvBindResponse> {
         std::unique_ptr<TPGBind> OriginalMessage;
 
         TEvBindResponse(std::unique_ptr<TPGBind> originalMessage)
@@ -152,7 +152,7 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvBind : NActors::TEventLocal<TEvBind, EvBind> {
+    struct TEvBind : NActors::TEventLight<TEvBind, EvBind> {
         std::unique_ptr<TPGBind> Message;
 
         TEvBind(std::unique_ptr<TPGBind> message)
@@ -164,7 +164,7 @@ struct TEvPGEvents {
         }
     };
 
-    struct TEvDescribe : NActors::TEventLocal<TEvDescribe, EvDescribe> {
+    struct TEvDescribe : NActors::TEventLight<TEvDescribe, EvDescribe> {
         std::unique_ptr<TPGDescribe> Message;
 
         TEvDescribe(std::unique_ptr<TPGDescribe> message)
@@ -172,12 +172,12 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvDescribeResponse : NActors::TEventLocal<TEvDescribeResponse, EvDescribeResponse> {
+    struct TEvDescribeResponse : NActors::TEventLight<TEvDescribeResponse, EvDescribeResponse> {
         std::vector<TRowDescriptionField> DataFields;
         std::vector<std::pair<char, TString>> ErrorFields;
     };
 
-    struct TEvExecute : NActors::TEventLocal<TEvExecute, EvExecute> {
+    struct TEvExecute : NActors::TEventLight<TEvExecute, EvExecute> {
         std::unique_ptr<TPGExecute> Message;
 
         TEvExecute(std::unique_ptr<TPGExecute> message)
@@ -185,7 +185,7 @@ struct TEvPGEvents {
         {}
     };
 
-    struct TEvExecuteResponse : NActors::TEventLocal<TEvExecuteResponse, EvExecuteResponse> {
+    struct TEvExecuteResponse : NActors::TEventLight<TEvExecuteResponse, EvExecuteResponse> {
         std::vector<TDataRow> DataRows;
         std::vector<std::pair<char, TString>> ErrorFields;
     };
diff --git a/ydb/core/pgproxy/pg_proxy_ut.cpp b/ydb/core/pgproxy/pg_proxy_ut.cpp
index 2e02e98deee..f7577084b68 100644
--- a/ydb/core/pgproxy/pg_proxy_ut.cpp
+++ b/ydb/core/pgproxy/pg_proxy_ut.cpp
@@ -67,7 +67,8 @@ Y_UNIT_TEST_SUITE(TPGTest) {
         NPG::TEvPGEvents::TEvAuth* authRequest = actorSystem.GrabEdgeEvent<NPG::TEvPGEvents::TEvAuth>(handle);
         UNIT_ASSERT(authRequest);
         UNIT_ASSERT_VALUES_EQUAL(authRequest->InitialMessage->GetClientParams()["user"], "user");
-        actorSystem.Send(new NActors::IEventHandle(handle->Sender, database, new NPG::TEvPGEvents::TEvAuthResponse()));
+        auto* ev = new NPG::TEvPGEvents::TEvAuthResponse();        ;
+        actorSystem.Send(ev->PrepareSend(handle->Sender, database));
         TString received = Receive(s);
         UNIT_ASSERT_VALUES_EQUAL(received, "520000000800000000530000001B496E74657276616C5374796C6500706F737467726573005300000012446174655374796C650049534F0053000000197365727665725F656E636F64696E670055544638005300000019696E74656765725F6461746574696D6573006F6E005300000019636C69656E745F656E636F64696E670055544638005A0000000549");
     }
diff --git a/ydb/core/public_http/http_service.cpp b/ydb/core/public_http/http_service.cpp
index d12c67c6bc0..f82cd447333 100644
--- a/ydb/core/public_http/http_service.cpp
+++ b/ydb/core/public_http/http_service.cpp
@@ -66,7 +66,7 @@ namespace {
             ev->CertificateFile = Config.GetCert();
             ev->PrivateKeyFile = Config.GetKey();
 
-            ctx.Send(new NActors::IEventHandle(MakePublicHttpServerID(), TActorId(), ev.Release(), 0, true));
+            ctx.Send(new NActors::IEventHandleFat(MakePublicHttpServerID(), TActorId(), ev.Release(), 0, true));
             ctx.Send(MakePublicHttpServerID(), new NHttp::TEvHttpProxy::TEvRegisterHandler("/", MakePublicHttpID()));
         }
 
@@ -119,7 +119,7 @@ namespace {
             return;
         }
 
-        
+
         auto actor = NKikimr::NPublicHttp::CreatePublicHttp(config, appData.Counters->GetSubgroup("counters", "public_http"));
         localServices.push_back(std::pair<TActorId, TActorSetupCmd>(
             MakePublicHttpID(),
diff --git a/ydb/core/quoter/kesus_quoter_proxy.cpp b/ydb/core/quoter/kesus_quoter_proxy.cpp
index e13d46ddf15..a609804d57e 100644
--- a/ydb/core/quoter/kesus_quoter_proxy.cpp
+++ b/ydb/core/quoter/kesus_quoter_proxy.cpp
@@ -471,7 +471,7 @@ private:
         if (!Connected) {
             for (auto&& alloc : OfflineAllocationEvSchedule) {
                 KESUS_PROXY_LOG_TRACE("Schedule offline allocation in " << alloc.first << ": " << PrintResources(*alloc.second));
-                TAutoPtr<IEventHandle> h = new IEventHandle(SelfId(), SelfId(), alloc.second.Release(), 0, OfflineAllocationCookie);
+                TAutoPtr<IEventHandle> h = new IEventHandleFat(SelfId(), SelfId(), alloc.second.Release(), 0, OfflineAllocationCookie);
                 TActivationContext::Schedule(alloc.first, std::move(h));
             }
         }
@@ -905,7 +905,7 @@ public:
                 KESUS_PROXY_LOG_WARN("TKesusQuoterProxy::StateFunc unexpected event type# "
                     << ev->GetTypeRewrite()
                     << " event: "
-                    << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                    << ev->ToString());
                 Y_VERIFY_DEBUG(false, "Unknown event");
                 break;
         }
diff --git a/ydb/core/quoter/quoter_service_impl.h b/ydb/core/quoter/quoter_service_impl.h
index 98eb1525ade..e27da7ced6b 100644
--- a/ydb/core/quoter/quoter_service_impl.h
+++ b/ydb/core/quoter/quoter_service_impl.h
@@ -322,7 +322,7 @@ public:
             LOG_WARN_S(ctx, NKikimrServices::QUOTER_SERVICE, "TQuoterService::StateFunc unexpected event type# "
                 << ev->GetTypeRewrite()
                 << " event: "
-                << TString(ev->HasEvent() ? ev->GetBase()->ToString() : "serialized?"));
+                << ev->ToString());
             break;
         }
 
diff --git a/ydb/core/quoter/quoter_service_ut.cpp b/ydb/core/quoter/quoter_service_ut.cpp
index 88c74ca3fb1..8d764176012 100644
--- a/ydb/core/quoter/quoter_service_ut.cpp
+++ b/ydb/core/quoter/quoter_service_ut.cpp
@@ -26,7 +26,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
 
         TActorId sender = runtime->AllocateEdgeActor();
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceForbid, 1)
                     }, TDuration::Max())));
@@ -35,7 +35,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             UNIT_ASSERT(reply->Result == TEvQuota::TEvClearance::EResult::Deadline);
         }
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceNocheck, 1)
                     }, TDuration::Max())));
@@ -45,7 +45,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
         }
 
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(1, 1000), 1)
                     }, TDuration::Max())));
@@ -58,7 +58,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             // test static quter queues processing
             size_t cnt = 100;
             for (size_t i = 0; i < cnt; ++i) {
-                runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+                runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                     new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                         TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(2, 50), 1)
                         }, TDuration::Max()), 0, 300 + i));
@@ -75,7 +75,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
         {
             auto resId = TEvQuota::TResourceLeaf::MakeTaggedRateRes(1, 1);
 
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, resId, 1)
                     }, TDuration::Max())));
@@ -83,7 +83,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             THolder<TEvQuota::TEvClearance> reply = runtime->GrabEdgeEvent<TEvQuota::TEvClearance>();
             UNIT_ASSERT(reply->Result == TEvQuota::TEvClearance::EResult::Success);
 
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, resId, 1000, true)
                     }, TDuration::Seconds(1))));
@@ -91,7 +91,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             reply = runtime->GrabEdgeEvent<TEvQuota::TEvClearance>();
             UNIT_ASSERT(reply->Result == TEvQuota::TEvClearance::EResult::Success);
 
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, resId, 1000)
                     }, TDuration::Seconds(1))));
@@ -99,7 +99,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             reply = runtime->GrabEdgeEvent<TEvQuota::TEvClearance>();
             UNIT_ASSERT(reply->Result == TEvQuota::TEvClearance::EResult::Deadline);
 
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, resId, 1000, true)
                     }, TDuration::Seconds(1))));
@@ -204,7 +204,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             const TInstant start = TInstant::Now();
             size_t sent = 0;
             while (TInstant::Now() - start < testDuration) {
-                runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+                runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                                                new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, { resLeaf }, waitDuration), 0, 0));
                 ++sent;
                 if ((sent & 3) != 0) {
@@ -267,7 +267,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
 
         TActorId sender = runtime->AllocateEdgeActor();
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceForbid, 1),
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceNocheck, 1),
@@ -277,7 +277,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
             UNIT_ASSERT(reply->Result == TEvQuota::TEvClearance::EResult::Deadline);
         }
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceNocheck, 1),
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceNocheck, 1),
@@ -288,7 +288,7 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
         }
 
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(1, 1000), 1),
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::ResourceNocheck, 1),
@@ -310,17 +310,17 @@ Y_UNIT_TEST_SUITE(TQuoterServiceTest) {
 
         TActorId sender = runtime->AllocateEdgeActor();
         {
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(1, 10), 20)
                     }, TDuration::Seconds(3))));
 
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(1, 10), 20)
                     }, TDuration::Seconds(3))));
 
-            runtime->Send(new IEventHandle(MakeQuoterServiceID(), sender,
+            runtime->Send(new IEventHandleFat(MakeQuoterServiceID(), sender,
                 new TEvQuota::TEvRequest(TEvQuota::EResourceOperator::And, {
                     TEvQuota::TResourceLeaf(TEvQuota::TResourceLeaf::QuoterSystem, TEvQuota::TResourceLeaf::MakeTaggedRateRes(1, 10), 20)
                     }, TDuration::Seconds(3))));
diff --git a/ydb/core/quoter/ut_helpers.cpp b/ydb/core/quoter/ut_helpers.cpp
index e57a073d74a..c3f57318961 100644
--- a/ydb/core/quoter/ut_helpers.cpp
+++ b/ydb/core/quoter/ut_helpers.cpp
@@ -135,7 +135,7 @@ void TKesusQuoterTestSetup::SendGetQuotaRequest(const std::vector<std::tuple<TSt
     for (auto&& [kesusPath, resourcePath, amount] : resources) {
         res.emplace_back(kesusPath, resourcePath, amount);
     }
-    GetServer().GetRuntime()->Send(new IEventHandle(MakeQuoterServiceID(), GetEdgeActor(), new TEvQuota::TEvRequest(operation, std::move(res), deadline)));
+    GetServer().GetRuntime()->Send(new IEventHandleFat(MakeQuoterServiceID(), GetEdgeActor(), new TEvQuota::TEvRequest(operation, std::move(res), deadline)));
 }
 
 void TKesusQuoterTestSetup::SendGetQuotaRequest(const TString& kesusPath, const TString& resourcePath, ui64 amount) {
@@ -237,17 +237,17 @@ void TKesusProxyTestSetup::WaitProxyStart() {
 
 void TKesusProxyTestSetup::SendNotConnected(TTestTabletPipeFactory::TTestTabletPipe* pipe) {
     WaitProxyStart();
-    Runtime->Send(new IEventHandle(KesusProxyId, pipe->GetSelfID(), new TEvTabletPipe::TEvClientConnected(KESUS_TABLET_ID, NKikimrProto::ERROR, pipe->GetSelfID(), TActorId(), true, false)), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, pipe->GetSelfID(), new TEvTabletPipe::TEvClientConnected(KESUS_TABLET_ID, NKikimrProto::ERROR, pipe->GetSelfID(), TActorId(), true, false)), 0, true);
 }
 
 void TKesusProxyTestSetup::SendConnected(TTestTabletPipeFactory::TTestTabletPipe* pipe) {
     WaitProxyStart();
-    Runtime->Send(new IEventHandle(KesusProxyId, pipe->GetSelfID(), new TEvTabletPipe::TEvClientConnected(KESUS_TABLET_ID, NKikimrProto::OK, pipe->GetSelfID(), pipe->GetSelfID(), true, false)), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, pipe->GetSelfID(), new TEvTabletPipe::TEvClientConnected(KESUS_TABLET_ID, NKikimrProto::OK, pipe->GetSelfID(), pipe->GetSelfID(), true, false)), 0, true);
 }
 
 void TKesusProxyTestSetup::SendDestroyed(TTestTabletPipeFactory::TTestTabletPipe* pipe) {
     WaitProxyStart();
-    Runtime->Send(new IEventHandle(KesusProxyId, pipe->GetSelfID(), new TEvTabletPipe::TEvClientDestroyed(KESUS_TABLET_ID, pipe->GetSelfID(), pipe->GetSelfID())), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, pipe->GetSelfID(), new TEvTabletPipe::TEvClientDestroyed(KESUS_TABLET_ID, pipe->GetSelfID(), pipe->GetSelfID())), 0, true);
 }
 
 void TKesusProxyTestSetup::WaitPipesCreated(size_t count) {
@@ -299,32 +299,32 @@ void TKesusProxyTestSetup::WaitConnected() {
 
 void TKesusProxyTestSetup::SendProxyRequest(const TString& resourceName) {
     WaitProxyStart();
-    Runtime->Send(new IEventHandle(KesusProxyId, GetEdgeActor(), new TEvQuota::TEvProxyRequest(resourceName)), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, GetEdgeActor(), new TEvQuota::TEvProxyRequest(resourceName)), 0, true);
 }
 
-THolder<TEventHandle<TEvQuota::TEvProxySession>> TKesusProxyTestSetup::ProxyRequest(const TString& resourceName, TEvQuota::TEvProxySession::EResult expectedResult) {
+THolder<TEventHandleFat<TEvQuota::TEvProxySession>> TKesusProxyTestSetup::ProxyRequest(const TString& resourceName, TEvQuota::TEvProxySession::EResult expectedResult) {
     SendProxyRequest(resourceName);
 
     TAutoPtr<IEventHandle> handle;
     TEvQuota::TEvProxySession* ret = Runtime->GrabEdgeEvent<TEvQuota::TEvProxySession>(handle);
     UNIT_ASSERT_EQUAL_C(ret->Result, expectedResult, "Actual result: " << static_cast<int>(ret->Result) << ", but expected: " << static_cast<int>(expectedResult));
-    return THolder<TEventHandle<TEvQuota::TEvProxySession>>{static_cast<TEventHandle<TEvQuota::TEvProxySession>*>(handle.Release())};
+    return THolder<TEventHandleFat<TEvQuota::TEvProxySession>>{static_cast<TEventHandleFat<TEvQuota::TEvProxySession>*>(handle.Release())};
 }
 
 void TKesusProxyTestSetup::SendProxyStats(TDeque<TEvQuota::TProxyStat> stats) {
     WaitProxyStart();
-    Runtime->Send(new IEventHandle(KesusProxyId, GetEdgeActor(), new TEvQuota::TEvProxyStats(std::move(stats))), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, GetEdgeActor(), new TEvQuota::TEvProxyStats(std::move(stats))), 0, true);
 }
 
-THolder<TEventHandle<TEvQuota::TEvProxyUpdate>> TKesusProxyTestSetup::GetProxyUpdate() {
+THolder<TEventHandleFat<TEvQuota::TEvProxyUpdate>> TKesusProxyTestSetup::GetProxyUpdate() {
     TAutoPtr<IEventHandle> handle;
     Runtime->GrabEdgeEvent<TEvQuota::TEvProxyUpdate>(handle);
-    return THolder<TEventHandle<TEvQuota::TEvProxyUpdate>>{static_cast<TEventHandle<TEvQuota::TEvProxyUpdate>*>(handle.Release())};
+    return THolder<TEventHandleFat<TEvQuota::TEvProxyUpdate>>{static_cast<TEventHandleFat<TEvQuota::TEvProxyUpdate>*>(handle.Release())};
 }
 
 void TKesusProxyTestSetup::SendCloseSession(const TString& resource, ui64 resourceId) {
     WaitProxyStart();
-    Runtime->Send(new IEventHandle(KesusProxyId, GetEdgeActor(), new TEvQuota::TEvProxyCloseSession(resource, resourceId)), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, GetEdgeActor(), new TEvQuota::TEvProxyCloseSession(resource, resourceId)), 0, true);
 }
 
 void TKesusProxyTestSetup::SendResourcesAllocated(TTestTabletPipeFactory::TTestTabletPipe* pipe, ui64 resId, double amount, Ydb::StatusIds::StatusCode status) {
@@ -334,7 +334,7 @@ void TKesusProxyTestSetup::SendResourcesAllocated(TTestTabletPipeFactory::TTestT
     resInfo->SetAmount(amount);
     resInfo->MutableStateNotification()->SetStatus(status);
 
-    Runtime->Send(new IEventHandle(KesusProxyId, pipe->GetSelfID(), new NKesus::TEvKesus::TEvResourcesAllocated(std::move(ev))), 0, true);
+    Runtime->Send(new IEventHandleFat(KesusProxyId, pipe->GetSelfID(), new NKesus::TEvKesus::TEvResourcesAllocated(std::move(ev))), 0, true);
 }
 
 bool TKesusProxyTestSetup::ConsumeResource(ui64 resId, double amount, TDuration tickSize, std::function<void()> afterStat, const size_t maxUpdates) {
@@ -499,7 +499,7 @@ void TKesusProxyTestSetup::TTestTabletPipeFactory::TTestTabletPipe::SendUpdateCo
 }
 
 THolder<IEventHandle> TKesusProxyTestSetup::TTestTabletPipeFactory::TTestTabletPipe::GetDestroyedEventHandle() {
-    return MakeHolder<IEventHandle>(Parent->Parent->KesusProxyId, SelfID, new TEvTabletPipe::TEvClientDestroyed(KESUS_TABLET_ID, SelfID, SelfID));
+    return MakeHolder<IEventHandleFat>(Parent->Parent->KesusProxyId, SelfID, new TEvTabletPipe::TEvClientDestroyed(KESUS_TABLET_ID, SelfID, SelfID));
 }
 
 } // namespace NKikimr
diff --git a/ydb/core/quoter/ut_helpers.h b/ydb/core/quoter/ut_helpers.h
index ea76fdc0ae1..6ebc843cb63 100644
--- a/ydb/core/quoter/ut_helpers.h
+++ b/ydb/core/quoter/ut_helpers.h
@@ -187,10 +187,10 @@ public:
     TActorId GetPipeEdgeActor();
 
     void SendProxyRequest(const TString& resourceName);
-    THolder<TEventHandle<TEvQuota::TEvProxySession>> ProxyRequest(const TString& resourceName, TEvQuota::TEvProxySession::EResult = TEvQuota::TEvProxySession::Success);
+    THolder<TEventHandleFat<TEvQuota::TEvProxySession>> ProxyRequest(const TString& resourceName, TEvQuota::TEvProxySession::EResult = TEvQuota::TEvProxySession::Success);
 
     void SendProxyStats(TDeque<TEvQuota::TProxyStat> stats);
-    THolder<TEventHandle<TEvQuota::TEvProxyUpdate>> GetProxyUpdate();
+    THolder<TEventHandleFat<TEvQuota::TEvProxyUpdate>> GetProxyUpdate();
 
     void SendCloseSession(const TString& resource, ui64 resourceId);
 
diff --git a/ydb/core/security/ticket_parser_impl.h b/ydb/core/security/ticket_parser_impl.h
index 852ae106779..12dd6e5776c 100644
--- a/ydb/core/security/ticket_parser_impl.h
+++ b/ydb/core/security/ticket_parser_impl.h
@@ -870,7 +870,7 @@ protected:
         THashMap<TString, TPermissionRecord> Permissions;
         TString Subject; // login
         TEvTicketParser::TError Error;
-        TDeque<THolder<TEventHandle<TEvTicketParser::TEvAuthorizeTicket>>> AuthorizeRequests;
+        TDeque<THolder<TEventHandleFat<TEvTicketParser::TEvAuthorizeTicket>>> AuthorizeRequests;
         ui64 ResponsesLeft = 0;
         TInstant InitTime;
         TInstant RefreshTime;
diff --git a/ydb/core/security/ticket_parser_ut.cpp b/ydb/core/security/ticket_parser_ut.cpp
index b4590a91c54..39fd96a7a8b 100644
--- a/ydb/core/security/ticket_parser_ut.cpp
+++ b/ydb/core/security/ticket_parser_ut.cpp
@@ -43,12 +43,12 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         provider.RotateKeys();
 
         TActorId sender = runtime->AllocateEdgeActor();
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
 
         provider.CreateUser({.User = "user1", .Password = "password1"});
         auto loginResponse = provider.LoginUser({.User = "user1", .Password = "password1"});
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(loginResponse.Token)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(loginResponse.Token)), 0);
 
         TAutoPtr<IEventHandle> handle;
 
@@ -89,13 +89,13 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         provider.CreateUser({.User = "user1", .Password = "password1"});
         provider.AddGroupMembership({.Group = "group1", .Member = "user1"});
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
 
         auto loginResponse = provider.LoginUser({.User = "user1", .Password = "password1"});
 
         UNIT_ASSERT_VALUES_EQUAL(loginResponse.Error, "");
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(loginResponse.Token)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(loginResponse.Token)), 0);
 
         TAutoPtr<IEventHandle> handle;
 
@@ -132,9 +132,9 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         provider.RotateKeys();
 
         TActorId sender = runtime->AllocateEdgeActor();
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket("Login bad-token")), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket("Login bad-token")), 0);
 
         TAutoPtr<IEventHandle> handle;
 
@@ -168,14 +168,14 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         provider.RotateKeys();
 
         TActorId sender = runtime->AllocateEdgeActor();
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvUpdateLoginSecurityState(provider.GetSecurityState())), 0);
 
         provider.CreateUser({.User = "user1", .Password = "password1"});
         auto loginResponse = provider.LoginUser({.User = "user1", .Password = "password1"});
 
         TString emptyUserToken = "";
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(emptyUserToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(emptyUserToken)), 0);
 
         TAutoPtr<IEventHandle> handle;
 
@@ -219,7 +219,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         builder.AddListeningPort(accessServiceEndpoint, grpc::InsecureServerCredentials()).RegisterService(&accessServiceMock);
         std::unique_ptr<grpc::Server> accessServer(builder.BuildAndStart());
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), runtime->AllocateEdgeActor(), new TEvTicketParser::TEvAuthorizeTicket("Bearer " + userToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), runtime->AllocateEdgeActor(), new TEvTicketParser::TEvAuthorizeTicket("Bearer " + userToken)), 0);
 
         TAutoPtr<IEventHandle> handle;
         TEvTicketParser::TEvAuthorizeTicketResult* result = runtime->GrabEdgeEvent<TEvTicketParser::TEvAuthorizeTicketResult>(handle);
@@ -274,7 +274,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TActorId sender = runtime->AllocateEdgeActor();
         TAutoPtr<IEventHandle> handle;
 
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
         TEvTicketParser::TEvAuthorizeTicketResult* result = runtime->GrabEdgeEvent<TEvTicketParser::TEvAuthorizeTicketResult>(handle);
         UNIT_ASSERT(result->Error.empty());
         UNIT_ASSERT_VALUES_EQUAL(result->Token->GetUserSID(), "login1@passport");
@@ -318,7 +318,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         accessServiceMock.UnavailableTokens.insert(userToken);
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
         TEvTicketParser::TEvAuthorizeTicketResult* result = runtime->GrabEdgeEvent<TEvTicketParser::TEvAuthorizeTicketResult>(handle);
         UNIT_ASSERT(!result->Error.empty());
         UNIT_ASSERT(result->Error.Retryable);
@@ -364,7 +364,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         accessServiceMock.UnavailableTokens.insert(userToken);
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
         TEvTicketParser::TEvAuthorizeTicketResult* result = runtime->GrabEdgeEvent<TEvTicketParser::TEvAuthorizeTicketResult>(handle);
         UNIT_ASSERT(!result->Error.empty());
         UNIT_ASSERT(!result->Error.Retryable);
@@ -409,7 +409,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         accessServiceMock.UnavailableTokens.insert(userToken);
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(userToken)), 0);
         TEvTicketParser::TEvAuthorizeTicketResult* result = runtime->GrabEdgeEvent<TEvTicketParser::TEvAuthorizeTicketResult>(handle);
         UNIT_ASSERT(!result->Error.empty());
         UNIT_ASSERT(!result->Error.Retryable);
@@ -454,7 +454,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         // Authorization successful.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -464,7 +464,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT(!result->Token->IsExist("something.write-bbbb4554@as"));
 
         // Authorization failure with not enough permissions.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.write"})), 0);
@@ -474,7 +474,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT(!result->Error.Retryable);
 
         // Authorization successful.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -484,7 +484,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT(!result->Token->IsExist("something.write-bbbb4554@as"));
 
         // Authorization failure with invalid token.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            "invalid",
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -494,7 +494,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT_VALUES_EQUAL(result->Error.Message, "Access Denied");
 
         // Authorization failure with access denied token.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            "invalid-token1",
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -505,7 +505,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
 
         // Authorization failure with wrong folder_id.
         accessServiceMock.AllowedResourceIds.emplace("cccc1234");
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "XXXXXXXX"}, {"database_id", "XXXXXXXX"}},
                                            {"something.read"})), 0);
@@ -516,7 +516,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
 
         // Authorization successful with right folder_id.
         accessServiceMock.AllowedResourceIds.emplace("aaaa1234");
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "XXXXXXXX"}},
                                            {"something.read"})), 0);
@@ -527,7 +527,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         // Authorization successful with right database_id.
         accessServiceMock.AllowedResourceIds.clear();
         accessServiceMock.AllowedResourceIds.emplace("bbbb4554");
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "XXXXXXXX"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -574,7 +574,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         // Authorization successful.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            TVector<TEvTicketParser::TEvAuthorizeTicket::TPermission>{TEvTicketParser::TEvAuthorizeTicket::Optional("something.read"), TEvTicketParser::TEvAuthorizeTicket::Optional("something.write")})), 0);
@@ -584,7 +584,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT(!result->Token->IsExist("something.write-bbbb4554@as"));
 
         // Authorization failure with not enough permissions.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            TVector<TEvTicketParser::TEvAuthorizeTicket::TPermission>{TEvTicketParser::TEvAuthorizeTicket::Optional("something.read"), TEvTicketParser::TEvAuthorizeTicket::Required("something.write")})), 0);
@@ -646,7 +646,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         // Authorization successful.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -657,7 +657,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT_VALUES_EQUAL(result->Token->GetUserSID(), "login1@passport");
 
         // Authorization failure with not enough permissions.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.write"})), 0);
@@ -667,7 +667,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT_VALUES_EQUAL(result->Error.Message, "Access Denied");
 
         // Authorization successful.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -680,7 +680,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         accessServiceMock.AllowedUserPermissions.insert("user1-something.write");
 
         // Authorization successful - 2
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            TVector<TString>{"something.read", "something.write"})), 0);
@@ -745,7 +745,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         accessServiceMock.AllowedUserPermissions.erase("user1-something.read");
 
         // Authorization successful - 2
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.list", "something.read", "something.write", "something.eat", "somewhere.sleep"})), 0);
@@ -797,7 +797,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         accessServiceMock.UnavailableUserPermissions.insert(userToken + "-something.write");
 
         // Authorization unsuccessfull.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            TVector<TString>{"something.read", "something.write"})), 0);
@@ -845,7 +845,7 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         TAutoPtr<IEventHandle> handle;
 
         // Authorization successful.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            {"something.read"})), 0);
@@ -855,10 +855,10 @@ Y_UNIT_TEST_SUITE(TTicketParserTest) {
         UNIT_ASSERT(!result->Token->IsExist("something.write-bbbb4554@as"));
 
         accessServiceMock.AllowedUserPermissions.insert(userToken + "-something.write");
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvDiscardTicket(userToken)), 0);
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvDiscardTicket(userToken)), 0);
 
         // Authorization successful with new permissions.
-        runtime->Send(new IEventHandle(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
+        runtime->Send(new IEventHandleFat(MakeTicketParserID(), sender, new TEvTicketParser::TEvAuthorizeTicket(
                                            userToken,
                                            {{"folder_id", "aaaa1234"}, {"database_id", "bbbb4554"}},
                                            TVector<TString>{"something.read", "something.write"})), 0);
diff --git a/ydb/core/sys_view/partition_stats/partition_stats_ut.cpp b/ydb/core/sys_view/partition_stats/partition_stats_ut.cpp
index 83189b339df..d4eddee38c2 100644
--- a/ydb/core/sys_view/partition_stats/partition_stats_ut.cpp
+++ b/ydb/core/sys_view/partition_stats/partition_stats_ut.cpp
@@ -40,7 +40,7 @@ Y_UNIT_TEST_SUITE(PartitionStats) {
                 auto setPartitioning = MakeHolder<TEvSysView::TEvSetPartitioning>(domainKey, id, "");
                 setPartitioning->ShardIndices.push_back(TShardIdx(ownerId * 3 + pathId, 0));
                 setPartitioning->ShardIndices.push_back(TShardIdx(ownerId * 3 + pathId, 1));
-                runtime.Send(new IEventHandle(collectorId, TActorId(), setPartitioning.Release()));
+                runtime.Send(new IEventHandleFat(collectorId, TActorId(), setPartitioning.Release()));
             }
         }
 
@@ -79,7 +79,7 @@ Y_UNIT_TEST_SUITE(PartitionStats) {
             auto checkIt = check.begin();
 
             while (true) {
-                runtime.Send(new IEventHandle(collectorId, sender, get.Release()));
+                runtime.Send(new IEventHandleFat(collectorId, sender, get.Release()));
 
                 TAutoPtr<IEventHandle> handle;
                 auto result = runtime.GrabEdgeEvent<TEvSysView::TEvGetPartitionStatsResult>(handle);
@@ -196,7 +196,7 @@ Y_UNIT_TEST_SUITE(PartitionStats) {
         record.SetDomainKeyOwnerId(domainKey.OwnerId);
         record.SetDomainKeyPathId(domainKey.LocalPathId);
 
-        runtime.Send(new IEventHandle(collectorId, sender, get.Release()));
+        runtime.Send(new IEventHandleFat(collectorId, sender, get.Release()));
 
         TAutoPtr<IEventHandle> handle;
         auto result = runtime.GrabEdgeEvent<TEvSysView::TEvGetPartitionStatsResult>(handle);
diff --git a/ydb/core/sys_view/ut_kqp.cpp b/ydb/core/sys_view/ut_kqp.cpp
index a7a52485159..c5bd8bdf6b0 100644
--- a/ydb/core/sys_view/ut_kqp.cpp
+++ b/ydb/core/sys_view/ut_kqp.cpp
@@ -400,7 +400,7 @@ Y_UNIT_TEST_SUITE(SystemView) {
             stats->QueryStats.SetEndTimeMs(endTimeUs / 1000);
 
             auto serviceId = MakeSysViewServiceID(runtime->GetNodeId(nodeIdx));
-            runtime->Send(new IEventHandle(serviceId, TActorId(), stats.Release()), nodeIdx);
+            runtime->Send(new IEventHandleFat(serviceId, TActorId(), stats.Release()), nodeIdx);
         };
 
         makeQueryEvent(tenant1Node0, buckets[0], "a", 100);
@@ -809,7 +809,7 @@ Y_UNIT_TEST_SUITE(SystemView) {
         ).GetValueSync());
 
         auto serviceToKill = MakeSysViewServiceID(env.GetServer().GetRuntime()->GetNodeId(2));
-        env.GetServer().GetRuntime()->Send(new IEventHandle(serviceToKill, TActorId(), new TEvents::TEvPoison()));
+        env.GetServer().GetRuntime()->Send(new IEventHandleFat(serviceToKill, TActorId(), new TEvents::TEvPoison()));
 
         auto it = client.StreamExecuteScanQuery(R"(
             SELECT
diff --git a/ydb/core/tablet/bootstrapper.cpp b/ydb/core/tablet/bootstrapper.cpp
index 17653b92d8f..9d3d1ac631f 100644
--- a/ydb/core/tablet/bootstrapper.cpp
+++ b/ydb/core/tablet/bootstrapper.cpp
@@ -370,7 +370,7 @@ class TBootstrapper : public TActor<TBootstrapper> {
 
         ctx.ExecutorThread.ActorSystem->Schedule(
             Min(sleepDuration, BootDelayedUntil - now),
-            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(), 0, RoundCounter));
+            new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(), 0, RoundCounter));
         Become(&TThis::StateSleep);
         return false;
     }
@@ -413,7 +413,7 @@ class TBootstrapper : public TActor<TBootstrapper> {
             const auto sleepDuration = TDuration::MicroSeconds(wx / 2 + wx * (SelfSeed % 0x10000) / 0x20000);
 
             Become(&TThis::StateSleep);
-            ctx.ExecutorThread.ActorSystem->Schedule(sleepDuration, new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(), 0, RoundCounter));
+            ctx.ExecutorThread.ActorSystem->Schedule(sleepDuration, new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup(), 0, RoundCounter));
             return;
         } else if (!CheckBootPermitted(undelivered, disconnected, ctx)) {
             return;
@@ -568,7 +568,7 @@ public:
 
     TAutoPtr<IEventHandle> AfterRegister(const TActorId &selfId, const TActorId &parentId) override {
         Y_UNUSED(parentId);
-        return new IEventHandle(selfId, selfId, new TEvents::TEvBootstrap());
+        return new IEventHandleFat(selfId, selfId, new TEvents::TEvBootstrap());
     }
 
     STFUNC(StateBoot) {
diff --git a/ydb/core/tablet/resource_broker_impl.h b/ydb/core/tablet/resource_broker_impl.h
index 42ef1406261..8f08a9f7ba9 100644
--- a/ydb/core/tablet/resource_broker_impl.h
+++ b/ydb/core/tablet/resource_broker_impl.h
@@ -460,7 +460,7 @@ public:
         default:
             Y_FAIL("TResourceBroker::StateWork unexpected event type: %" PRIx32 " event: %s",
                    ev->GetTypeRewrite(),
-                   ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                   ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/tablet/resource_broker_ut.cpp b/ydb/core/tablet/resource_broker_ut.cpp
index aa2ba8131c0..294e3da53b7 100644
--- a/ydb/core/tablet/resource_broker_ut.cpp
+++ b/ydb/core/tablet/resource_broker_ut.cpp
@@ -91,7 +91,7 @@ SubmitTask(TTestActorRuntime &runtime, TActorId broker, TActorId sender,
                                                type,
                                                priority,
                                                cookie);
-    runtime.Send(new IEventHandle(broker, sender, event.Release()));
+    runtime.Send(new IEventHandleFat(broker, sender, event.Release()));
 }
 
 static void
@@ -104,7 +104,7 @@ UpdateTask(TTestActorRuntime &runtime, TActorId broker, TActorId sender,
                                                {{cpu, memory}},
                                                type, priority, resubmit);
 
-    runtime.Send(new IEventHandle(broker, sender, event.Release()));
+    runtime.Send(new IEventHandleFat(broker, sender, event.Release()));
 }
 
 static void
@@ -114,7 +114,7 @@ UpdateTaskCookie(TTestActorRuntime &runtime, TActorId broker, TActorId sender,
     TAutoPtr<TEvResourceBroker::TEvUpdateTaskCookie> event
         = new TEvResourceBroker::TEvUpdateTaskCookie(id, cookie);
 
-    runtime.Send(new IEventHandle(broker, sender, event.Release()));
+    runtime.Send(new IEventHandleFat(broker, sender, event.Release()));
 }
 
 static void
@@ -123,7 +123,7 @@ RemoveTask(TTestActorRuntime &runtime, TActorId broker, TActorId sender, ui64 id
     TAutoPtr<TEvResourceBroker::TEvRemoveTask> event
         = new TEvResourceBroker::TEvRemoveTask(id);
 
-    runtime.Send(new IEventHandle(broker, sender, event.Release()));
+    runtime.Send(new IEventHandleFat(broker, sender, event.Release()));
 }
 
 static void
@@ -132,7 +132,7 @@ FinishTask(TTestActorRuntime &runtime, TActorId broker, TActorId sender, ui64 id
     TAutoPtr<TEvResourceBroker::TEvFinishTask> event
         = new TEvResourceBroker::TEvFinishTask(id);
 
-    runtime.Send(new IEventHandle(broker, sender, event.Release()));
+    runtime.Send(new IEventHandleFat(broker, sender, event.Release()));
 }
 
 static ui64
@@ -176,7 +176,7 @@ static void CheckConfigure(TTestActorRuntime &runtime, TActorId broker, TActorId
 {
     TAutoPtr<TEvResourceBroker::TEvConfigure> event = new TEvResourceBroker::TEvConfigure;
     event->Record.CopyFrom(config);
-    runtime.Send(new IEventHandle(broker, sender, event.Release()));
+    runtime.Send(new IEventHandleFat(broker, sender, event.Release()));
 
     TAutoPtr<IEventHandle> handle;
     auto reply = runtime.GrabEdgeEventRethrow<TEvResourceBroker::TEvConfigureResult>(handle);
@@ -187,7 +187,7 @@ static void CheckConfigure(TTestActorRuntime &runtime, TActorId broker, TActorId
 
 static
 TIntrusivePtr<IResourceBroker> GetInstantResourceBroker(TTestActorRuntime &runtime, TActorId broker, TActorId sender) {
-    runtime.Send(new IEventHandle(broker, sender, new TEvResourceBroker::TEvResourceBrokerRequest));
+    runtime.Send(new IEventHandleFat(broker, sender, new TEvResourceBroker::TEvResourceBrokerRequest));
     auto answer = runtime.GrabEdgeEvent<TEvResourceBroker::TEvResourceBrokerResponse>(sender);
     return answer->Get()->ResourceBroker;
 }
@@ -576,7 +576,7 @@ Y_UNIT_TEST_SUITE(TResourceBroker) {
         config.MutableQueues(1)->SetWeight(50);
         TAutoPtr<TEvResourceBroker::TEvConfigure> event1 = new TEvResourceBroker::TEvConfigure;
         event1->Record.CopyFrom(config);
-        runtime.Send(new IEventHandle(brokerId, sender, event1.Release()));
+        runtime.Send(new IEventHandleFat(brokerId, sender, event1.Release()));
 
         WaitForResourceAllocation(runtime, 2);
         WaitForResourceAllocation(runtime, 3);
@@ -671,7 +671,7 @@ Y_UNIT_TEST_SUITE(TResourceBroker) {
         // Remove task-1 and task-2.
         now += TDuration::Seconds(1);
         runtime.UpdateCurrentTime(now);
-        runtime.Send(new IEventHandle(brokerId, sender1, new TEvResourceBroker::TEvNotifyActorDied));
+        runtime.Send(new IEventHandleFat(brokerId, sender1, new TEvResourceBroker::TEvNotifyActorDied));
 
         // Get resources for task-4.
         WaitForResourceAllocation(runtime, 4);
diff --git a/ydb/core/tablet/tablet_counters_aggregator_ut.cpp b/ydb/core/tablet/tablet_counters_aggregator_ut.cpp
index f94a11f898f..8984dd863ea 100644
--- a/ydb/core/tablet/tablet_counters_aggregator_ut.cpp
+++ b/ydb/core/tablet/tablet_counters_aggregator_ut.cpp
@@ -51,7 +51,7 @@ void TestHeavy(const ui32 v, ui32 numWorkers) {
         for (auto i = 1; i <= NODES; ++i) {
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(i, "::", "localhost", "localhost", 1234, TNodeLocation()));
         }
-        runtime.Send(new NActors::IEventHandle(a, edge, nodesInfo.Release()), 0, true);
+        runtime.Send(new NActors::IEventHandleFat(a, edge, nodesInfo.Release()), 0, true);
     }
 
     for (auto i = 1; i <= NODES; ++i) {
@@ -72,7 +72,7 @@ void TestHeavy(const ui32 v, ui32 numWorkers) {
             }
         }
         Cerr << "Sending message to " << cc[i % numWorkers] << " from " << aggregatorId <<  " id " << i << "\n";
-        runtime.Send(new NActors::IEventHandle(cc[i % numWorkers], aggregatorId, response.Release(), 0, i), 0, true);
+        runtime.Send(new NActors::IEventHandleFat(cc[i % numWorkers], aggregatorId, response.Release(), 0, i), 0, true);
     }
     {
         TDispatchOptions options;
@@ -124,21 +124,21 @@ Y_UNIT_TEST_SUITE(TTabletCountersAggregator) {
             auto appCounters = AppCounters->MakeDiffForAggr(*AppCountersBaseline);
             AppCounters->RememberCurrentStateAsBaseline(*AppCountersBaseline);
 
-            runtime.Send(new IEventHandle(aggregatorId, sender, new TEvTabletCounters::TEvTabletAddCounters(
+            runtime.Send(new IEventHandleFat(aggregatorId, sender, new TEvTabletCounters::TEvTabletAddCounters(
                 CounterEventsInFlight, TabletId, TabletType, TenantPathId, executorCounters, appCounters)));
 
             // force recalc
-            runtime.Send(new IEventHandle(aggregatorId, sender, new NActors::TEvents::TEvWakeup()));
+            runtime.Send(new IEventHandleFat(aggregatorId, sender, new NActors::TEvents::TEvWakeup()));
         }
 
         void ForgetTablet(TTestBasicRuntime& runtime, const TActorId& aggregatorId, const TActorId& sender) {
-            runtime.Send(new IEventHandle(
+            runtime.Send(new IEventHandleFat(
                 aggregatorId,
                 sender,
                 new TEvTabletCounters::TEvTabletCountersForgetTablet(TabletId, TabletType, TenantPathId)));
 
             // force recalc
-            runtime.Send(new IEventHandle(aggregatorId, sender, new NActors::TEvents::TEvWakeup()));
+            runtime.Send(new IEventHandleFat(aggregatorId, sender, new NActors::TEvents::TEvWakeup()));
         }
 
         void SetSimpleCount(const char* name, ui64 count) {
@@ -677,7 +677,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(1, "::", "localhost", "localhost", 1234, TNodeLocation()));
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(2, "::", "localhost", "localhost", 1234, TNodeLocation()));
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(3, "::", "localhost", "localhost", 1234, TNodeLocation()));
-            runtime.Send(new NActors::IEventHandle(a, edge, nodesInfo.Release()), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(a, edge, nodesInfo.Release()), 0, true);
         }
 
         {
@@ -691,7 +691,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             counter1.SetValue(13);
             counter1.SetType(TLabeledCounterOptions::CT_SIMPLE);
             counter1.SetAggregateFunc(TLabeledCounterOptions::EAF_SUM);
-            runtime.Send(new NActors::IEventHandle(cc[0], edge, response.Release(), 0, 1), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(cc[0], edge, response.Release(), 0, 1), 0, true);
         }
 
         {
@@ -706,7 +706,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             counter1.SetValue(13);
             counter1.SetType(TLabeledCounterOptions::CT_SIMPLE);
             counter1.SetAggregateFunc(TLabeledCounterOptions::EAF_SUM);
-            runtime.Send(new NActors::IEventHandle(cc[1], edge, response.Release(), 0, 2), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(cc[1], edge, response.Release(), 0, 2), 0, true);
         }
 
         {
@@ -721,7 +721,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             counter1.SetValue(13);
             counter1.SetType(TLabeledCounterOptions::CT_SIMPLE);
             counter1.SetAggregateFunc(TLabeledCounterOptions::EAF_SUM);
-            runtime.Send(new NActors::IEventHandle(cc[2], edge, response.Release(), 0, 3), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(cc[2], edge, response.Release(), 0, 3), 0, true);
         }
 
         runtime.DispatchEvents();
@@ -777,7 +777,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(1, "::", "localhost", "localhost", 1234, TNodeLocation()));
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(2, "::", "localhost", "localhost", 1234, TNodeLocation()));
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(3, "::", "localhost", "localhost", 1234, TNodeLocation()));
-            runtime.Send(new NActors::IEventHandle(a, edge, nodesInfo.Release()), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(a, edge, nodesInfo.Release()), 0, true);
         }
 
         {
@@ -791,7 +791,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             counter1.SetValue(13);
             counter1.SetType(TLabeledCounterOptions::CT_SIMPLE);
             counter1.SetAggregateFunc(TLabeledCounterOptions::EAF_SUM);
-            runtime.Send(new NActors::IEventHandle(cc[0], edge, response.Release(), 0, 1), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(cc[0], edge, response.Release(), 0, 1), 0, true);
         }
 
         {
@@ -806,7 +806,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             counter1.SetValue(13);
             counter1.SetType(TLabeledCounterOptions::CT_SIMPLE);
             counter1.SetAggregateFunc(TLabeledCounterOptions::EAF_SUM);
-            runtime.Send(new NActors::IEventHandle(cc[1], edge, response.Release(), 0, 2), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(cc[1], edge, response.Release(), 0, 2), 0, true);
         }
 
         runtime.DispatchEvents();
@@ -853,7 +853,7 @@ Y_UNIT_TEST_SUITE(TTabletLabeledCountersAggregator) {
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(1, "::", "localhost", "localhost", 1234, TNodeLocation()));
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(2, "::", "localhost", "localhost", 1234, TNodeLocation()));
             nodesInfo->Nodes.emplace_back(TEvInterconnect::TNodeInfo(3, "::", "localhost", "localhost", 1234, TNodeLocation()));
-            runtime.Send(new NActors::IEventHandle(a, edge, nodesInfo.Release()), 0, true);
+            runtime.Send(new NActors::IEventHandleFat(a, edge, nodesInfo.Release()), 0, true);
         }
 
         NPrivate::TDbLabeledCounters PQCounters;
diff --git a/ydb/core/tablet/tablet_pipe_client.cpp b/ydb/core/tablet/tablet_pipe_client.cpp
index 225abef7853..af9340dc3bb 100644
--- a/ydb/core/tablet/tablet_pipe_client.cpp
+++ b/ydb/core/tablet/tablet_pipe_client.cpp
@@ -255,7 +255,7 @@ namespace NTabletPipe {
         }
 
         void Connect(const TActorContext &ctx) {
-            SendEvent(new IEventHandle(GetTabletLeader(), ctx.SelfID, new TEvTabletPipe::TEvConnect(TabletId, ctx.SelfID, GenerateConnectFeatures()),
+            SendEvent(new IEventHandleFat(GetTabletLeader(), ctx.SelfID, new TEvTabletPipe::TEvConnect(TabletId, ctx.SelfID, GenerateConnectFeatures()),
                 IEventHandle::FlagTrackDelivery, ++ConnectCookie), ctx);
             Become(&TThis::StateConnect);
         }
@@ -547,14 +547,22 @@ namespace NTabletPipe {
                     case TEvTabletPipe::EvSend: {
                         Type = ev->Type;
                         Sender = ev->Sender;
-                        if (ev->HasEvent()) {
-                            if (ev->HasBuffer()) {
-                                // Grab both the buffer and the event
-                                Buffer = ev->GetChainBuffer();
+                        if (ev->IsEventFat()) {
+                            auto* evf = IEventHandleFat::GetFat(ev);
+                            if (evf->HasEvent()) {
+                                if (evf->HasBuffer()) {
+                                    // Grab both the buffer and the event
+                                    Buffer = evf->GetChainBuffer();
+                                }
+                                Event.Reset(evf->ReleaseBase().Release());
+                            } else {
+                                Buffer = evf->ReleaseChainBuffer();
                             }
-                            Event.Reset(ev->ReleaseBase().Release());
-                        } else {
-                            Buffer = ev->ReleaseChainBuffer();
+                        } else if (ev->IsEventSerializable()) {
+                            auto* evs = IEventHandleLightSerializable::GetLightSerializable(ev);
+                            TAllocChunkSerializer serializer;
+                            evs->Serializer(evs, &serializer);
+                            Buffer = serializer.Release(TEventSerializationInfo{});
                         }
                         SeqNo = 0;
                         break;
@@ -599,21 +607,34 @@ namespace NTabletPipe {
                 switch (ev->GetTypeRewrite()) {
                     case TEvTabletPipe::EvMessage: {
                         // Send local self -> server message without conversions
-                        THolder<TEvTabletPipe::TEvMessage> msg(ev->Release<TEvTabletPipe::TEvMessage>().Release());
-                        ctx.ExecutorThread.Send(new IEventHandle(ServerId, SelfId(), msg.Release(),
-                                IEventHandle::FlagTrackDelivery, ev->Cookie, nullptr, std::move(ev->TraceId)));
+                        if (ev->IsEventLight()) {
+                            IEventHandleLight* evl = IEventHandleLight::ReleaseLight(ev);
+                            Send(ServerId, evl, IEventHandle::FlagTrackDelivery, evl->Cookie, std::move(evl->TraceId));
+                        } else {
+                            IEventHandleFat* evf = IEventHandleFat::GetFat(ev);
+                            THolder<TEvTabletPipe::TEvMessage> msg(evf->Release<TEvTabletPipe::TEvMessage>().Release());
+                            msg->PrepareSend(ServerId, SelfId(), IEventHandle::FlagTrackDelivery, ev->Cookie, std::move(evf->TraceId));
+                            ctx.ExecutorThread.Send(msg.Release());
+                        }
                         break;
                     }
                     case TEvTabletPipe::EvSend: {
                         // Repackage event in a self -> sender form with an original type
                         THolder<IEventHandle> directEv;
-                        if (ev->HasEvent()) {
-                            directEv = MakeHolder<IEventHandle>(ev->Sender, SelfId(), ev->ReleaseBase().Release(),
-                                    IEventHandle::FlagTrackDelivery, ev->Cookie, nullptr, std::move(ev->TraceId));
+                        if (ev->IsEventLight()) {
+                            IEventHandleLight* evl = IEventHandleLight::GetLight(ev);
+                            evl->PrepareSend(evl->Sender, SelfId(), IEventHandle::FlagTrackDelivery);
+                            directEv = ev;
                         } else {
-                            directEv = MakeHolder<IEventHandle>(ev->Type, IEventHandle::FlagTrackDelivery,
-                                    ev->Sender, SelfId(), ev->ReleaseChainBuffer(), ev->Cookie, nullptr,
-                                    std::move(ev->TraceId));
+                            IEventHandleFat* evf = IEventHandleFat::GetFat(ev);
+                            if (evf->HasEvent()) {
+                                directEv = MakeHolder<IEventHandleFat>(ev->Sender, SelfId(), evf->ReleaseBase().Release(),
+                                        IEventHandle::FlagTrackDelivery, ev->Cookie, nullptr, std::move(evf->TraceId));
+                            } else {
+                                directEv = MakeHolder<IEventHandleFat>(ev->Type, IEventHandle::FlagTrackDelivery,
+                                        ev->Sender, SelfId(), evf->ReleaseChainBuffer(), ev->Cookie, nullptr,
+                                        std::move(evf->TraceId));
+                            }
                         }
                         // Rewrite into EvSend and send to the server
                         directEv->Rewrite(TEvTabletPipe::EvSend, ServerId);
@@ -628,7 +649,7 @@ namespace NTabletPipe {
                     SupportsDataInPayload);
 
                 // Send a remote self -> server message
-                SendEvent(new IEventHandle(ServerId, SelfId(), msg.Release(), IEventHandle::FlagTrackDelivery, 0,
+                SendEvent(new IEventHandleFat(ServerId, SelfId(), msg.Release(), IEventHandle::FlagTrackDelivery, 0,
                     nullptr, std::move(ev->TraceId)), ctx);
             }
         }
@@ -685,7 +706,7 @@ namespace NTabletPipe {
     }
 
     void SendData(TActorId self, TActorId clientId, IEventBase *payload, ui64 cookie, NWilson::TTraceId traceId) {
-        auto ev = new IEventHandle(clientId, self, payload, 0, cookie, nullptr, std::move(traceId));
+        auto ev = new IEventHandleFat(clientId, self, payload, 0, cookie, nullptr, std::move(traceId));
         ev->Rewrite(TEvTabletPipe::EvSend, clientId);
         TActivationContext::Send(ev);
     }
@@ -697,24 +718,24 @@ namespace NTabletPipe {
     void SendDataWithSeqNo(TActorId self, TActorId clientId, IEventBase *payload, ui64 seqNo, ui64 cookie, NWilson::TTraceId traceId) {
         auto event = MakeHolder<TEvTabletPipe::TEvMessage>(self, THolder<IEventBase>(payload));
         event->SetSeqNo(seqNo);
-        auto ev = MakeHolder<IEventHandle>(clientId, self, event.Release(), 0, cookie, nullptr, std::move(traceId));
-        TActivationContext::Send(ev.Release());
+        event->PrepareSend(clientId, self, 0, cookie, std::move(traceId));
+        TActivationContext::Send(event.Release());
     }
 
     void SendData(TActorId self, TActorId clientId, ui32 eventType, TIntrusivePtr<TEventSerializedData> buffer, ui64 cookie, NWilson::TTraceId traceId) {
-        auto ev = new IEventHandle(eventType, 0, clientId, self, buffer, cookie, nullptr, std::move(traceId));
+        auto ev = new IEventHandleFat(eventType, 0, clientId, self, buffer, cookie, nullptr, std::move(traceId));
         ev->Rewrite(TEvTabletPipe::EvSend, clientId);
         TActivationContext::Send(ev);
     }
 
     void SendData(const TActorContext& ctx, const TActorId& clientId, IEventBase* payload, ui64 cookie, NWilson::TTraceId traceId) {
-        auto ev = new IEventHandle(clientId, ctx.SelfID, payload, 0, cookie, nullptr, std::move(traceId));
+        auto ev = new IEventHandleFat(clientId, ctx.SelfID, payload, 0, cookie, nullptr, std::move(traceId));
         ev->Rewrite(TEvTabletPipe::EvSend, clientId);
         ctx.ExecutorThread.Send(ev);
     }
 
     void SendData(const TActorContext& ctx, const TActorId& clientId, ui32 eventType, TIntrusivePtr<TEventSerializedData> buffer, ui64 cookie, NWilson::TTraceId traceId) {
-        auto ev = new IEventHandle(eventType, 0, clientId, ctx.SelfID, buffer, cookie, nullptr, std::move(traceId));
+        auto ev = new IEventHandleFat(eventType, 0, clientId, ctx.SelfID, buffer, cookie, nullptr, std::move(traceId));
         ev->Rewrite(TEvTabletPipe::EvSend, clientId);
         ctx.ExecutorThread.Send(ev);
     }
diff --git a/ydb/core/tablet/tablet_pipe_server.cpp b/ydb/core/tablet/tablet_pipe_server.cpp
index ca6a67bc8fe..2119ed029c0 100644
--- a/ydb/core/tablet/tablet_pipe_server.cpp
+++ b/ydb/core/tablet/tablet_pipe_server.cpp
@@ -81,7 +81,7 @@ namespace NTabletPipe {
                 ? MakeIntrusive<TEventSerializedData>(TRope(msg.GetPayload(0)), std::move(serializationInfo))
                 : MakeIntrusive<TEventSerializedData>(record.GetBuffer(), std::move(serializationInfo));
 
-            auto result = std::make_unique<IEventHandle>(
+            auto result = std::make_unique<IEventHandleFat>(
                     ev->InterconnectSession,
                     record.GetType(),
                     0,
@@ -113,11 +113,11 @@ namespace NTabletPipe {
 
             THolder<IEventHandle> result;
             if (msg->HasEvent()) {
-                result = MakeHolder<IEventHandle>(ctx.SelfID, originalSender,
+                result = MakeHolder<IEventHandleFat>(ctx.SelfID, originalSender,
                         msg->ReleaseEvent().Release(), 0, ev->Cookie, nullptr,
                         std::move(ev->TraceId));
             } else {
-                result = MakeHolder<IEventHandle>(
+                result = MakeHolder<IEventHandleFat>(
                         msg->Type, 0, ctx.SelfID, originalSender,
                         msg->ReleaseBuffer(), ev->Cookie, nullptr,
                         std::move(ev->TraceId));
@@ -143,12 +143,18 @@ namespace NTabletPipe {
             }
 
             IEventHandle* result;
-            if (ev->HasEvent()) {
-                result = new IEventHandle(ctx.SelfID, originalSender, ev->ReleaseBase().Release(), 0, ev->Cookie, nullptr,
-                        std::move(ev->TraceId));
+            if (ev->IsEventLight()) {
+                result = ev.Release();
+                IEventHandleLight::GetLight(result)->PrepareSend(ctx.SelfID, originalSender, 0, ev->Cookie);
             } else {
-                result = new IEventHandle(ev->Type, 0, ctx.SelfID, originalSender, ev->ReleaseChainBuffer(), ev->Cookie,
-                        nullptr, std::move(ev->TraceId));
+                auto* fatEv = IEventHandleFat::GetFat(ev);
+                if (fatEv->HasEvent()) {
+                    result = new IEventHandleFat(ctx.SelfID, originalSender, fatEv->ReleaseBase().Release(), 0, ev->Cookie, nullptr,
+                            std::move(fatEv->TraceId));
+                } else {
+                    result = new IEventHandleFat(ev->Type, 0, ctx.SelfID, originalSender, fatEv->ReleaseChainBuffer(), ev->Cookie,
+                            nullptr, std::move(fatEv->TraceId));
+                }
             }
 
             result->Rewrite(ev->Type, RecipientId);
@@ -239,7 +245,7 @@ namespace NTabletPipe {
         }
 
         void SendToClient(const TActorContext& ctx, TAutoPtr<IEventBase> msg, ui32 flags = 0, ui64 cookie = 0) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(ClientId, ctx.SelfID, msg.Release(), flags, cookie);
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(ClientId, ctx.SelfID, msg.Release(), flags, cookie);
 
             if (InterconnectSession) {
                 ev->Rewrite(TEvInterconnect::EvForward, InterconnectSession);
diff --git a/ydb/core/tablet/tablet_pipe_ut.cpp b/ydb/core/tablet/tablet_pipe_ut.cpp
index c5ca50c2ace..955c36f6a01 100644
--- a/ydb/core/tablet/tablet_pipe_ut.cpp
+++ b/ydb/core/tablet/tablet_pipe_ut.cpp
@@ -496,7 +496,7 @@ Y_UNIT_TEST_SUITE(TTabletPipeTest) {
             // the client received the EvConnectResult
             runtime.SetObserverFunc([clientId, sender](TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& event) {
                 if (event->Type == TEvTabletPipe::EvConnect) {
-                    runtime.Send(new IEventHandle(clientId, sender, new TEvents::TEvPoisonPill()), 0);
+                    runtime.Send(new IEventHandleFat(clientId, sender, new TEvents::TEvPoisonPill()), 0);
                 }
                 return TTestActorRuntime::EEventAction::PROCESS;
             });
@@ -853,13 +853,13 @@ Y_UNIT_TEST_SUITE(TTabletPipeTest) {
 
         TActorId proxy = runtime.GetInterconnectProxy(0, 1);
         Y_VERIFY(proxy);
-        runtime.Send(new IEventHandle(proxy, sender1, new TEvInterconnect::TEvConnectNode), 0);
+        runtime.Send(new IEventHandleFat(proxy, sender1, new TEvInterconnect::TEvConnectNode), 0);
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
         auto sessionId = handle->Sender;
         Cout << "SessionId: " << sessionId << "\n";
 
-        runtime.Send(new IEventHandle(sessionId, sender1, new TEvents::TEvPoisonPill), 0);
+        runtime.Send(new IEventHandleFat(sessionId, sender1, new TEvents::TEvPoisonPill), 0);
         {
             TDispatchOptions options;
             options.FinalEvents.push_back(TDispatchOptions::TFinalEventCondition(TEvTabletPipe::EvClientConnected, 1));
@@ -1045,7 +1045,7 @@ Y_UNIT_TEST_SUITE(TTabletPipeTest) {
         TActorId edge2 = runtime.AllocateEdgeActor(1);
 
         // Make an event that is from edge1 to edge2, but rewritten for edge1
-        auto event = new IEventHandle(edge2, edge1, new TEvents::TEvWakeup());
+        auto event = new IEventHandleFat(edge2, edge1, new TEvents::TEvWakeup());
         event->Rewrite(TEvents::TSystem::Wakeup, edge1);
 
         // We send this event from node 1, which should be delivered to edge1
@@ -1089,7 +1089,7 @@ Y_UNIT_TEST_SUITE(TTabletPipeTest) {
         }
 
         void SendViaSession(const TActorId &sessionId, const TActorContext &ctx, const TActorId &recipient, TAutoPtr<IEventBase> msg, ui32 flags = 0, ui64 cookie = 0) {
-            TAutoPtr<IEventHandle> ev = new IEventHandle(recipient, ctx.SelfID, msg.Release(), flags, cookie);
+            TAutoPtr<IEventHandle> ev = new IEventHandleFat(recipient, ctx.SelfID, msg.Release(), flags, cookie);
 
             if (sessionId) {
                 ev->Rewrite(TEvInterconnect::EvForward, sessionId);
diff --git a/ydb/core/tablet/tablet_pipecache_ut.cpp b/ydb/core/tablet/tablet_pipecache_ut.cpp
index 15997a45539..051b09e368e 100644
--- a/ydb/core/tablet/tablet_pipecache_ut.cpp
+++ b/ydb/core/tablet/tablet_pipecache_ut.cpp
@@ -92,7 +92,7 @@ Y_UNIT_TEST_SUITE(TPipeCacheTest) {
         TActorId sender = runtime.AllocateEdgeActor();
         for (size_t i = 0; i < 20; ++i) {
             runtime.AdvanceCurrentTime(TDuration::Seconds(2));
-            runtime.Send(new IEventHandle(cacheActor, sender, new TEvPipeCache::TEvForward(
+            runtime.Send(new IEventHandleFat(cacheActor, sender, new TEvPipeCache::TEvForward(
                 new TEvCustomTablet::TEvHelloRequest,
                 TTestTxConfig::TxTablet0,
                 false)), 0, true);
@@ -112,7 +112,7 @@ Y_UNIT_TEST_SUITE(TPipeCacheTest) {
 
         TActorId sender = runtime.AllocateEdgeActor();
 
-        runtime.Send(new IEventHandle(cacheActor, sender, new TEvPipeCache::TEvGetTabletNode(TTestTxConfig::TxTablet0)));
+        runtime.Send(new IEventHandleFat(cacheActor, sender, new TEvPipeCache::TEvGetTabletNode(TTestTxConfig::TxTablet0)));
         auto ev1 = runtime.GrabEdgeEventRethrow<TEvPipeCache::TEvGetTabletNodeResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL(ev1->Get()->TabletId, TTestTxConfig::TxTablet0);
         UNIT_ASSERT_VALUES_EQUAL(ev1->Get()->NodeId, 0);
@@ -128,7 +128,7 @@ Y_UNIT_TEST_SUITE(TPipeCacheTest) {
             runtime.DispatchEvents(options);
         }
 
-        runtime.Send(new IEventHandle(cacheActor, sender, new TEvPipeCache::TEvGetTabletNode(TTestTxConfig::TxTablet0)));
+        runtime.Send(new IEventHandleFat(cacheActor, sender, new TEvPipeCache::TEvGetTabletNode(TTestTxConfig::TxTablet0)));
         auto ev2 = runtime.GrabEdgeEventRethrow<TEvPipeCache::TEvGetTabletNodeResult>(sender);
         UNIT_ASSERT_VALUES_EQUAL(ev2->Get()->TabletId, TTestTxConfig::TxTablet0);
         UNIT_ASSERT_VALUES_EQUAL(ev2->Get()->NodeId, runtime.GetNodeId(0));
diff --git a/ydb/core/tablet/tablet_resolver.cpp b/ydb/core/tablet/tablet_resolver.cpp
index 369af9138fb..95375245cb9 100644
--- a/ydb/core/tablet/tablet_resolver.cpp
+++ b/ydb/core/tablet/tablet_resolver.cpp
@@ -312,8 +312,10 @@ class TTabletResolver : public TActorBootstrapped<TTabletResolver> {
         const std::pair<TActorId, TActorId> endpoint = SelectForward(ctx, entry, info, msg->TabletID);
         if (endpoint.first) {
             ctx.Send(sender, new TEvTabletResolver::TEvForwardResult(msg->TabletID, endpoint.second, endpoint.first, LastCacheEpoch));
-            if (!!msg->Ev)
-                ctx.ExecutorThread.Send(msg->Ev->Forward(msg->SelectActor(endpoint.second, endpoint.first)));
+            if (!!msg->Ev) {
+                IEventHandle::Forward(msg->Ev, msg->SelectActor(endpoint.second, endpoint.first));
+                ctx.ExecutorThread.Send(msg->Ev);
+            }
             return true;
         } else {
             return false;
@@ -863,7 +865,7 @@ public:
             HFunc(TEvents::TEvUndelivered, Handle);
             default:
                 LOG_WARN(ctx, NKikimrServices::TABLET_RESOLVER, "TTabletResolver::StateWork unexpected event type: %" PRIx32
-                    " event: %s", ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                    " event: %s", ev->GetTypeRewrite(), ev->ToString().data());
                 break;
         }
     }
diff --git a/ydb/core/tablet/tablet_resolver_ut.cpp b/ydb/core/tablet/tablet_resolver_ut.cpp
index b341cae1331..4139f689700 100644
--- a/ydb/core/tablet/tablet_resolver_ut.cpp
+++ b/ydb/core/tablet/tablet_resolver_ut.cpp
@@ -107,13 +107,13 @@ Y_UNIT_TEST_SUITE(TTabletResolver) {
 
     THolder<TEvTabletResolver::TEvForwardResult> DoResolveTablet(TTestBasicRuntime& runtime, ui64 tabletId) {
         const TActorId edge = runtime.AllocateEdgeActor();
-        runtime.Send(new IEventHandle(MakeTabletResolverID(), edge, new TEvTabletResolver::TEvForward(tabletId, nullptr)));
+        runtime.Send(new IEventHandleFat(MakeTabletResolverID(), edge, new TEvTabletResolver::TEvForward(tabletId, nullptr)));
         auto ev = runtime.GrabEdgeEventRethrow<TEvTabletResolver::TEvForwardResult>(edge);
         return std::move(ev->Release());
     }
 
     void DoSendNodeProblem(TTestBasicRuntime& runtime, ui32 nodeId, ui64 problemEpoch) {
-        runtime.Send(new IEventHandle(MakeTabletResolverID(), TActorId(), new TEvTabletResolver::TEvNodeProblem(nodeId, problemEpoch)));
+        runtime.Send(new IEventHandleFat(MakeTabletResolverID(), TActorId(), new TEvTabletResolver::TEvNodeProblem(nodeId, problemEpoch)));
     }
 
     Y_UNIT_TEST(NodeProblem) {
diff --git a/ydb/core/tablet/tablet_sys.cpp b/ydb/core/tablet/tablet_sys.cpp
index 3093463924c..f3dea6e7192 100644
--- a/ydb/core/tablet/tablet_sys.cpp
+++ b/ydb/core/tablet/tablet_sys.cpp
@@ -326,7 +326,7 @@ void TTablet::HandleStateStorageLeaderResolve(TEvStateStorage::TEvInfo::TPtr &ev
         NextFollowerAttempt();
 
         TActivationContext::Schedule(TDuration::MilliSeconds(100),
-                new IEventHandle(SelfId(), SelfId(),
+                new IEventHandleFat(SelfId(), SelfId(),
                     new TEvTabletBase::TEvFollowerRetry(++FollowerInfo.RetryRound),
                     0, FollowerInfo.FollowerAttempt)
         );
@@ -1857,14 +1857,14 @@ TTablet::TTablet(const TActorId &launcher, TTabletStorageInfo *info, TTabletSetu
 
 TAutoPtr<IEventHandle> TTablet::AfterRegister(const TActorId &self, const TActorId& parentId) {
     Y_UNUSED(parentId);
-    return new IEventHandle(self, self, new TEvents::TEvBootstrap());
+    return new IEventHandleFat(self, self, new TEvents::TEvBootstrap());
 }
 
 void TTablet::RetryFollowerBootstrapOrWait() {
     if (FollowerInfo.RetryRound) {
         ReportTabletStateChange(TTabletStateInfo::ResolveLeader);
 
-        TActivationContext::Schedule(TDuration::MilliSeconds(2000), new IEventHandle(
+        TActivationContext::Schedule(TDuration::MilliSeconds(2000), new IEventHandleFat(
             SelfId(), SelfId(),
             new TEvTabletBase::TEvFollowerRetry(++FollowerInfo.RetryRound),
             0, FollowerInfo.FollowerAttempt));
diff --git a/ydb/core/tablet_flat/flat_executor_ut.cpp b/ydb/core/tablet_flat/flat_executor_ut.cpp
index c5b3b298a88..91fcdb1c563 100644
--- a/ydb/core/tablet_flat/flat_executor_ut.cpp
+++ b/ydb/core/tablet_flat/flat_executor_ut.cpp
@@ -3485,7 +3485,7 @@ Y_UNIT_TEST_SUITE(TFlatTableExecutorFollower) {
             if (Debug) {
                 Cerr << "See follower detach, waking up" << Endl;
             }
-            ctx.Send(new IEventHandle(Edge, Edge, new TEvents::TEvWakeup()), 0, true);
+            ctx.Send(new IEventHandleFat(Edge, Edge, new TEvents::TEvWakeup()), 0, true);
             Detached = true;
         }
 
@@ -3509,7 +3509,7 @@ Y_UNIT_TEST_SUITE(TFlatTableExecutorFollower) {
                 if (Debug) {
                     Cerr << "...killing the follower tablet" << Endl;
                 }
-                ctx.Send(new IEventHandle(FollowerTabletActor, LeaderTabletActor, new TEvents::TEvPoison()), 0, true);
+                ctx.Send(new IEventHandleFat(FollowerTabletActor, LeaderTabletActor, new TEvents::TEvPoison()), 0, true);
             }
         }
 
diff --git a/ydb/core/tablet_flat/flat_executor_ut_common.h b/ydb/core/tablet_flat/flat_executor_ut_common.h
index ca88e903d08..7d517092ee1 100644
--- a/ydb/core/tablet_flat/flat_executor_ut_common.h
+++ b/ydb/core/tablet_flat/flat_executor_ut_common.h
@@ -113,7 +113,7 @@ namespace NTabletFlatExecutor {
 
         void SendEv(const TActorId &to, IEventBase *ev)
         {
-            Env.Send(new IEventHandle(to, Edge, ev));
+            Env.Send(new IEventHandleFat(to, Edge, ev));
         }
 
         static NTabletPipe::TClientConfig PipeCfgRetries()
diff --git a/ydb/core/tablet_flat/tablet_flat_executed.h b/ydb/core/tablet_flat/tablet_flat_executed.h
index c88281b25b6..309d847da6c 100644
--- a/ydb/core/tablet_flat/tablet_flat_executed.h
+++ b/ydb/core/tablet_flat/tablet_flat_executed.h
@@ -109,7 +109,7 @@ private:
                 if (!TTabletExecutedFlat::HandleDefaultEvents(ev, ctx))                             \
                     Y_VERIFY_DEBUG(false, "%s: unexpected event type: %" PRIx32 " event: %s",       \
                                    __func__, ev->GetTypeRewrite(),                                  \
-                                   ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");    \
+                                   ev->ToString().data());                                          \
         }                                                                                           \
     }
 
diff --git a/ydb/core/tablet_flat/test/libs/exec/dummy.h b/ydb/core/tablet_flat/test/libs/exec/dummy.h
index 3cea54ac9fb..b6299978e72 100644
--- a/ydb/core/tablet_flat/test/libs/exec/dummy.h
+++ b/ydb/core/tablet_flat/test/libs/exec/dummy.h
@@ -80,13 +80,13 @@ namespace NFake {
             } else if (eh->CastAsLocal<TEvTabletPipe::TEvServerDisconnected>()){
 
             } else if (!TTabletExecutedFlat::HandleDefaultEvents(eh, ctx)) {
-                Y_Fail("Unexpected event " << TypeName(*eh->GetBase()));
+                Y_Fail("Unexpected event " << eh->GetTypeName());
             }
         }
 
         void Enqueue(TEventHandlePtr &eh, const ::NActors::TActorContext&) override
         {
-            const auto *name = TypeName(*eh->GetBase()).c_str();
+            const auto *name = eh->GetTypeName().c_str();
 
             Y_FAIL("Got unexpected event %s on tablet booting", name);
         }
diff --git a/ydb/core/tablet_flat/test/libs/exec/leader.h b/ydb/core/tablet_flat/test/libs/exec/leader.h
index 61f03869af8..fa3bc0646d8 100644
--- a/ydb/core/tablet_flat/test/libs/exec/leader.h
+++ b/ydb/core/tablet_flat/test/libs/exec/leader.h
@@ -70,7 +70,7 @@ namespace NFake {
             } else if (eh->CastAsLocal<NFake::TEvTerm>()) {
 
             } else {
-                Y_Fail("Unexpected event " << TypeName(*eh->GetBase()));
+                Y_Fail("Unexpected event " << eh->GetTypeName());
             }
         }
 
diff --git a/ydb/core/tablet_flat/test/libs/exec/nanny.h b/ydb/core/tablet_flat/test/libs/exec/nanny.h
index b888da4ce6f..bb2ec49fdfe 100644
--- a/ydb/core/tablet_flat/test/libs/exec/nanny.h
+++ b/ydb/core/tablet_flat/test/libs/exec/nanny.h
@@ -134,7 +134,7 @@ namespace NFake {
             } else if (eh->CastAsLocal<TEvents::TEvPoison>()) {
                 DoSuicide();
             } else {
-                Y_Fail("Unexpected event " << TypeName(*eh->GetBase()));
+                Y_Fail("Unexpected event " << eh->GetTypeName());
             }
         }
 
diff --git a/ydb/core/tablet_flat/test/libs/exec/owner.h b/ydb/core/tablet_flat/test/libs/exec/owner.h
index 015e42cc448..1ebfb29a1e1 100644
--- a/ydb/core/tablet_flat/test/libs/exec/owner.h
+++ b/ydb/core/tablet_flat/test/libs/exec/owner.h
@@ -77,7 +77,7 @@ namespace NFake {
 
                 Send(Agent, new TEvents::TEvPoison);
             } else {
-                Y_Fail("Unexpected event " << TypeName(*eh->GetBase()));
+                Y_Fail("Unexpected event " << eh->GetTypeName());
             }
         }
 
diff --git a/ydb/core/tablet_flat/test/libs/exec/warden.h b/ydb/core/tablet_flat/test/libs/exec/warden.h
index 63b4a2526a1..899ea2ddb61 100644
--- a/ydb/core/tablet_flat/test/libs/exec/warden.h
+++ b/ydb/core/tablet_flat/test/libs/exec/warden.h
@@ -54,7 +54,7 @@ namespace NFake {
                     if (auto logl = Logger->Log(ELnLev::Abort)) {
                         logl
                             << "BS group " << group << " is not configured"
-                            << ", ev " << TypeName(*eh->GetBase());
+                            << ", ev " << eh->GetTypeName();
                     }
 
                     return; /* cannot process unknown groups */
@@ -70,17 +70,17 @@ namespace NFake {
                     if (auto logl = Logger->Log(ELnLev::Crit)) {
                         logl
                             << "BS group " << group << " is unavailable"
-                            << ", ev " << TypeName(*eh->GetBase());
+                            << ", ev " << eh->GetTypeName();
                     }
 
                     auto why = TEvents::TEvUndelivered::ReasonActorUnknown;
 
-                    TlsActivationContext->Send(eh->ForwardOnNondelivery(why));
+                    TlsActivationContext->Send(eh->ForwardOnNondelivery(eh, why));
 
                     return;
                 }
 
-                TlsActivationContext->Send(eh->Forward(proxy));
+                TlsActivationContext->Forward(eh, proxy);
 
             } else if (eh->CastAsLocal<TEvents::TEvPoison>()) {
                 if (std::exchange(Shutting, true)) {
diff --git a/ydb/core/test_tablet/load_actor_impl.cpp b/ydb/core/test_tablet/load_actor_impl.cpp
index bd190af76e4..5dd98cc2816 100644
--- a/ydb/core/test_tablet/load_actor_impl.cpp
+++ b/ydb/core/test_tablet/load_actor_impl.cpp
@@ -24,14 +24,14 @@ namespace NKikimr::NTestShard {
     void TLoadActor::PassAway() {
         Send(MakeStateServerInterfaceActorId(), new TEvStateServerDisconnect);
         if (ValidationActorId) {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, ValidationActorId, SelfId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, ValidationActorId, SelfId(), nullptr, 0));
         }
         TActorBootstrapped::PassAway();
     }
 
     void TLoadActor::HandleWakeup() {
         STLOG(PRI_NOTICE, TEST_SHARD, TS00, "voluntary restart", (TabletId, TabletId));
-        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, Tablet, TabletActorId, nullptr, 0));
+        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, Tablet, TabletActorId, nullptr, 0));
     }
 
     void TLoadActor::Action() {
@@ -57,7 +57,7 @@ namespace NKikimr::NTestShard {
             if (WritesInFlight.size() < Settings.GetMaxInFlight()) { // write until there is space in inflight
                 IssueWrite();
                 if (WritesInFlight.size() < Settings.GetMaxInFlight()) {
-                    TActivationContext::Send(new IEventHandle(EvDoSomeAction, 0, SelfId(), {}, nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(EvDoSomeAction, 0, SelfId(), {}, nullptr, 0));
                 }
             }
             if (BytesOfData > Settings.GetMaxDataBytes()) { // delete some data if needed
@@ -70,7 +70,7 @@ namespace NKikimr::NTestShard {
         if (ev->Get()->Connected) {
             RunValidation(true);
         } else {
-            TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
+            TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
             PassAway();
         }
     }
@@ -148,7 +148,7 @@ namespace NKikimr::NTestShard {
     }
 
     void TTestShard::PassAway() {
-        TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, ActivityActorId, {}, {}, 0));
+        TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, ActivityActorId, {}, {}, 0));
         TKeyValueFlat::PassAway();
     }
 
diff --git a/ydb/core/test_tablet/load_actor_read_validate.cpp b/ydb/core/test_tablet/load_actor_read_validate.cpp
index 71634ba4bc6..afaf89bc59b 100644
--- a/ydb/core/test_tablet/load_actor_read_validate.cpp
+++ b/ydb/core/test_tablet/load_actor_read_validate.cpp
@@ -78,7 +78,7 @@ namespace NKikimr::NTestShard {
                 IssueNextStateServerQuery();
             } else {
                 STLOG(PRI_ERROR, TEST_SHARD, TS05, "state server disconnected", (TabletId, TabletId));
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
                 PassAway();
             }
         }
@@ -293,7 +293,7 @@ namespace NKikimr::NTestShard {
                     Y_FAIL_S("ERROR from StateServer TabletId# " << TabletId);
 
                 case ::NTestShard::TStateServer::RACE:
-                    TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
                     PassAway();
                     return;
 
@@ -328,7 +328,7 @@ namespace NKikimr::NTestShard {
 
                 if (!KeyReadsWaitingForRetry.empty()) {
                     SendRetriesPending = true;
-                    TActivationContext::Schedule(TDuration::Seconds(10), new IEventHandle(EvRetryKeyReads, 0, SelfId(),
+                    TActivationContext::Schedule(TDuration::Seconds(10), new IEventHandleFat(EvRetryKeyReads, 0, SelfId(),
                         {}, nullptr, 0));
                     return;
                 }
@@ -443,7 +443,7 @@ namespace NKikimr::NTestShard {
                     Y_FAIL_S("ERROR from StateServer TabletId# " << TabletId);
 
                 case ::NTestShard::TStateServer::RACE:
-                    TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
+                    TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
                     PassAway();
                     return;
 
@@ -591,7 +591,7 @@ namespace NKikimr::NTestShard {
         Action();
 
         if (Settings.RestartPeriodsSize() && ev->Get()->InitialCheck) {
-            TActivationContext::Schedule(GenerateRandomInterval(Settings.GetRestartPeriods()), new IEventHandle(
+            TActivationContext::Schedule(GenerateRandomInterval(Settings.GetRestartPeriods()), new IEventHandleFat(
                 TEvents::TSystem::Wakeup, 0, SelfId(), {}, nullptr, 0));
         }
     }
diff --git a/ydb/core/test_tablet/load_actor_state.cpp b/ydb/core/test_tablet/load_actor_state.cpp
index adbd31cf53e..9027a1cf92a 100644
--- a/ydb/core/test_tablet/load_actor_state.cpp
+++ b/ydb/core/test_tablet/load_actor_state.cpp
@@ -45,7 +45,7 @@ namespace NKikimr::NTestShard {
                 Y_FAIL_S("ERROR from StateServer TabletId# " << TabletId);
 
             case ::NTestShard::TStateServer::RACE:
-                TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
+                TActivationContext::Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, TabletActorId, SelfId(), nullptr, 0));
                 PassAway();
                 return;
 
diff --git a/ydb/core/test_tablet/state_server_interface.cpp b/ydb/core/test_tablet/state_server_interface.cpp
index 8839763725e..1f03af8983d 100644
--- a/ydb/core/test_tablet/state_server_interface.cpp
+++ b/ydb/core/test_tablet/state_server_interface.cpp
@@ -169,7 +169,7 @@ namespace NKikimr::NTestShard {
             void ProcessPacket(TStateServerInterfaceActor *self) {
                 Y_VERIFY(!ResponseQ.empty());
                 TResponseInfo& response = ResponseQ.front();
-                TActivationContext::Send(new IEventHandle(response.Type, 0, response.Sender, self->SelfId(),
+                TActivationContext::Send(new IEventHandleFat(response.Type, 0, response.Sender, self->SelfId(),
                     MakeIntrusive<TEventSerializedData>(std::move(ReadBuffer), TEventSerializationInfo{}),
                     response.Cookie));
                 ResponseQ.pop_front();
diff --git a/ydb/core/testlib/actors/test_runtime.cpp b/ydb/core/testlib/actors/test_runtime.cpp
index 482b7b97e66..1e995b5ad92 100644
--- a/ydb/core/testlib/actors/test_runtime.cpp
+++ b/ydb/core/testlib/actors/test_runtime.cpp
@@ -229,7 +229,7 @@ namespace NActors {
         if (!SleepEdgeActor) {
             SleepEdgeActor = AllocateEdgeActor();
         }
-        Schedule(new IEventHandle(SleepEdgeActor, SleepEdgeActor, new TEvents::TEvWakeup()), duration);
+        Schedule(new IEventHandleFat(SleepEdgeActor, SleepEdgeActor, new TEvents::TEvWakeup()), duration);
         GrabEdgeEventRethrow<TEvents::TEvWakeup>(SleepEdgeActor);
     }
 
@@ -248,7 +248,7 @@ namespace NActors {
 
     void TTestActorRuntime::SendToPipe(TActorId clientId, const TActorId& sender, IEventBase* payload,
                                        ui32 nodeIndex, ui64 cookie) {
-        auto pipeEv = new IEventHandle(clientId, sender, payload, 0, cookie);
+        auto pipeEv = new IEventHandleFat(clientId, sender, payload, 0, cookie);
         pipeEv->Rewrite(NKikimr::TEvTabletPipe::EvSend, clientId);
         Send(pipeEv, nodeIndex, true);
     }
@@ -262,11 +262,11 @@ namespace NActors {
     }
 
     void TTestActorRuntime::ClosePipe(TActorId clientId, const TActorId& sender, ui32 nodeIndex) {
-        Send(new IEventHandle(clientId, sender, new NKikimr::TEvTabletPipe::TEvShutdown()), nodeIndex, true);
+        Send(new IEventHandleFat(clientId, sender, new NKikimr::TEvTabletPipe::TEvShutdown()), nodeIndex, true);
     }
 
     void TTestActorRuntime::DisconnectNodes(ui32 fromNodeIndex, ui32 toNodeIndex, bool async) {
-        Send(new IEventHandle(
+        Send(new IEventHandleFat(
             GetInterconnectProxy(fromNodeIndex, toNodeIndex),
             TActorId(),
             new TEvInterconnect::TEvDisconnect()),
diff --git a/ydb/core/testlib/actors/test_runtime_ut.cpp b/ydb/core/testlib/actors/test_runtime_ut.cpp
index fce7f192934..f1d5b052289 100644
--- a/ydb/core/testlib/actors/test_runtime_ut.cpp
+++ b/ydb/core/testlib/actors/test_runtime_ut.cpp
@@ -39,7 +39,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         runtime.Initialize(MakeEgg());
         TActorId sender = runtime.AllocateEdgeActor();
         TActorId actorId = runtime.Register(new TMyActor(sender));
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvWakeup));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvWakeup));
     }
 
     Y_UNIT_TEST(TestDie) {
@@ -61,7 +61,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         runtime.Initialize(MakeEgg());
         TActorId sender = runtime.AllocateEdgeActor();
         TActorId actorId = runtime.Register(new TMyActor);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPoisonPill));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPoisonPill));
     }
 
     Y_UNIT_TEST(TestStateSwitch) {
@@ -100,9 +100,9 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         TActorId sender = runtime.AllocateEdgeActor();
         auto actor = new TMyActor;
         TActorId actorId = runtime.Register(actor);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPing));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPing));
         UNIT_ASSERT_EQUAL(actor->IsStateChanged(), false);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPong));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPong));
         UNIT_ASSERT_EQUAL(actor->IsStateChanged(), true);
     }
 
@@ -124,7 +124,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         runtime.Initialize(MakeEgg());
         TActorId sender = runtime.AllocateEdgeActor();
         TActorId actorId = runtime.Register(new TMyActor);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPing));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPing));
         auto events = runtime.CaptureEvents();
         bool passed = false;
         for (const auto& event : events) {
@@ -163,7 +163,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
 
         TActorId sender = runtime.AllocateEdgeActor();
         TActorId actorId = runtime.Register(new TMyActor);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPing));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPing));
         auto scheduledEvents = runtime.CaptureScheduledEvents();
         UNIT_ASSERT_EQUAL_C(scheduledEvents.size(), 1, "check scheduled count");
         UNIT_ASSERT_C(scheduledEvents.begin()->Deadline == (runtime.GetCurrentTime() + TDuration::Seconds(1)), "scheduled delay check");
@@ -212,7 +212,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         TActorId sender = runtime.AllocateEdgeActor();
         auto actor = new TMyActor;
         TActorId actorId = runtime.Register(actor);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvWakeup));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvWakeup));
         auto events = runtime.CaptureEvents();
         bool passed = false;
         for (const auto& event : events) {
@@ -255,7 +255,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
                     with_lock(*syncMutex) {
                         Sleep(TDuration::MilliSeconds(100));
                         CurrentTime = actorSystem->Timestamp();
-                        actorSystem->Send(new IEventHandle(sender, selfID, new TEvents::TEvPong()));
+                        actorSystem->Send(new IEventHandleFat(sender, selfID, new TEvents::TEvPong()));
                     }
                 });
 
@@ -273,7 +273,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
             TActorId sender = runtime.AllocateEdgeActor();
             auto myActor = new TMyActor(&syncMutex);
             TActorId actorId = runtime.Register(myActor);
-            runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPing));
+            runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPing));
             runtime.DispatchEvents();
             auto events = runtime.CaptureEvents();
             UNIT_ASSERT_EQUAL_C(events.size(), 1, "check sent count");
@@ -336,7 +336,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         TActorId sender = runtime.AllocateEdgeActor();
         auto myActor = new TMyActor;
         TActorId actorId = runtime.Register(myActor);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvPing));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvPing));
         runtime.DispatchEvents();
         auto events = runtime.CaptureEvents();
         UNIT_ASSERT_EQUAL_C(events.size(), 1, "check sent count");
@@ -377,7 +377,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
                 Y_UNUSED(ctx);
                 switch (ev->GetTypeRewrite()) {
                 case EvCounter:
-                    ui32 eventCounter = reinterpret_cast<TEvCounter*>(ev->GetBase())->Counter;
+                    ui32 eventCounter = ev->CastAsLocal<TEvCounter>()->Counter;
                     UNIT_ASSERT_EQUAL_C(ExpectedCounter, eventCounter, "check counter");
                     ExpectedCounter = eventCounter + 1;
                     break;
@@ -416,7 +416,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
                 TProducerActor* actor = (TProducerActor*)(param);
                 for (ui32 i = 0; i < actor->Count; ++i) {
                     for (const auto& recip : actor->Recipents) {
-                        actor->ActorSystem->Send(new IEventHandle(recip, actor->SelfId, new TEvCounter(i)));
+                        actor->ActorSystem->Send(new IEventHandleFat(recip, actor->SelfId, new TEvCounter(i)));
                         if ((i % (1 + rand() % 100)) == 0) {
                             Sleep(TDuration::MilliSeconds(1 + rand() % 10));
                         }
@@ -452,7 +452,7 @@ Y_UNIT_TEST_SUITE(TActorTest) {
 
             auto producerActor = new TProducerActor(count, consumerIds);
             TActorId producerId = runtime.Register(producerActor);
-            runtime.Send(new IEventHandle(producerId, sender, new TEvents::TEvPing));
+            runtime.Send(new IEventHandleFat(producerId, sender, new TEvents::TEvPing));
             runtime.SetObserverFunc([](TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& event) {
                 Y_UNUSED(runtime);
                 Y_UNUSED(event);
@@ -521,11 +521,11 @@ Y_UNIT_TEST_SUITE(TActorTest) {
         TMyActor* myActor = new TMyActor;
         TActorId actorId = runtime.Register(myActor);
         runtime.EnableScheduleForActor(actorId);
-        runtime.Send(new IEventHandle(actorId, sender, new TEvents::TEvBootstrap()));
+        runtime.Send(new IEventHandleFat(actorId, sender, new TEvents::TEvBootstrap()));
         TAutoPtr<IEventHandle> handle;
         UNIT_ASSERT(runtime.GrabEdgeEventRethrow<TEvents::TEvCompleted>(handle));
-        runtime.Send(new IEventHandle(actorId, TActorId(), new TEvents::TEvPing()));
-        runtime.Schedule(new IEventHandle(sender, TActorId(), new TEvents::TEvWakeup()),
+        runtime.Send(new IEventHandleFat(actorId, TActorId(), new TEvents::TEvPing()));
+        runtime.Schedule(new IEventHandleFat(sender, TActorId(), new TEvents::TEvWakeup()),
             TDuration::MilliSeconds(1000000));
         do {
             runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(handle);
diff --git a/ydb/core/testlib/cs_helper.cpp b/ydb/core/testlib/cs_helper.cpp
index 42c2969113c..38723048bef 100644
--- a/ydb/core/testlib/cs_helper.cpp
+++ b/ydb/core/testlib/cs_helper.cpp
@@ -24,7 +24,7 @@ void THelperSchemaless::CreateTestOlapStore(TActorId sender, TString scheme) {
     op->SetWorkingDir(ROOT_PATH);
     op->MutableCreateColumnStore()->CopyFrom(store);
 
-    Server.GetRuntime()->Send(new IEventHandle(MakeTxProxyID(), sender, request.release()));
+    Server.GetRuntime()->Send(new IEventHandleFat(MakeTxProxyID(), sender, request.release()));
     auto ev = Server.GetRuntime()->GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
     ui64 txId = ev->Get()->Record.GetTxId();
     WaitForSchemeOperation(sender, txId);
@@ -46,7 +46,7 @@ void THelperSchemaless::CreateTestOlapTable(TActorId sender, TString storeOrDirN
     op->SetWorkingDir(workingDir);
     op->MutableCreateColumnTable()->CopyFrom(table);
 
-    Server.GetRuntime()->Send(new IEventHandle(MakeTxProxyID(), sender, request.release()));
+    Server.GetRuntime()->Send(new IEventHandleFat(MakeTxProxyID(), sender, request.release()));
     auto ev = Server.GetRuntime()->GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
     ui64 txId = ev->Get()->Record.GetTxId();
     auto status = ev->Get()->Record.GetStatus();
diff --git a/ydb/core/testlib/tablet_helpers.cpp b/ydb/core/testlib/tablet_helpers.cpp
index 41d4f3a391f..0e97ed55d36 100644
--- a/ydb/core/testlib/tablet_helpers.cpp
+++ b/ydb/core/testlib/tablet_helpers.cpp
@@ -167,7 +167,7 @@ namespace NKikimr {
         void OnEvent(TTestActorRuntimeBase& runtime, TAutoPtr<IEventHandle>& event) {
             Y_UNUSED(runtime);
             if (event->GetTypeRewrite() == TEvStateStorage::EvInfo) {
-                auto info = static_cast<TEvStateStorage::TEvInfo*>(event->GetBase());
+                auto info = event->CastAsLocal<TEvStateStorage::TEvInfo>();
                 if (info->Status == NKikimrProto::OK && (Find(TabletIds.begin(), TabletIds.end(), info->TabletID) != TabletIds.end())) {
                     if (ENABLE_REBOOT_DISPATCH_LOG) {
                         Cerr << "Leader for TabletID " << info->TabletID << " is " << info->CurrentLeaderTablet << " sender: " << event->Sender << " recipient: " << event->Recipient << Endl;
@@ -183,7 +183,7 @@ namespace NKikimr {
 
                 }
             } else if (event->GetTypeRewrite() == TEvFakeHive::EvNotifyTabletDeleted) {
-                auto notifyEv = static_cast<TEvFakeHive::TEvNotifyTabletDeleted*>(event->GetBase());
+                auto notifyEv = event->CastAsLocal<TEvFakeHive::TEvNotifyTabletDeleted>();
                 ui64 tabletId = notifyEv->TabletId;
                 DeletedTablets.insert(tabletId);
                 if (ENABLE_REBOOT_DISPATCH_LOG)
@@ -301,7 +301,7 @@ namespace NKikimr {
                 return TTestActorRuntime::EEventAction::PROCESS;
 
             HasReboot0 = true;
-            TString eventType = (event->HasEvent() && event->GetBase()) ? TypeName(*event->GetBase()) : "nullptr";
+            TString eventType = event->GetTypeName();
 
             if (KillOnCommit && IsCommitResult(event)) {
                 if (ENABLE_REBOOT_DISPATCH_LOG)
@@ -326,7 +326,7 @@ namespace NKikimr {
                 Cerr << "!Reboot " << TabletId << " (actor " << targetActorId << ") on event " << eventType << " !\n";
 
             // Wait for the tablet to boot or to become deleted
-            runtime.Send(new IEventHandle(targetActorId, TActorId(), new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(targetActorId, TActorId(), new TEvents::TEvPoisonPill()));
             TDispatchOptions rebootOptions;
             rebootOptions.FinalEvents.push_back(TDispatchOptions::TFinalEventCondition(TEvTablet::EvRestored, 2));
             rebootOptions.CustomFinalCondition = [this]() -> bool {
@@ -397,7 +397,7 @@ namespace NKikimr {
 
             // Replace the event with PoisonPill in order to kill PipeClient or PipeServer
             TActorId targetActorId = event->GetRecipientRewrite();
-            runtime.Send(new IEventHandle(targetActorId, TActorId(), new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(targetActorId, TActorId(), new TEvents::TEvPoisonPill()));
 
             return TTestActorRuntime::EEventAction::DROP;
         }
@@ -574,7 +574,7 @@ namespace NKikimr {
 
     TActorId ResolveTablet(TTestActorRuntime &runtime, ui64 tabletId, ui32 nodeIndex, bool sysTablet) {
         auto sender = runtime.AllocateEdgeActor(nodeIndex);
-        runtime.Send(new IEventHandle(MakeTabletResolverID(), sender,
+        runtime.Send(new IEventHandleFat(MakeTabletResolverID(), sender,
             new TEvTabletResolver::TEvForward(tabletId, nullptr)),
             nodeIndex, true);
         auto ev = runtime.GrabEdgeEventRethrow<TEvTabletResolver::TEvForwardResult>(sender);
@@ -587,13 +587,13 @@ namespace NKikimr {
     }
 
     void ForwardToTablet(TTestActorRuntime &runtime, ui64 tabletId, const TActorId& sender, IEventBase *ev, ui32 nodeIndex, bool sysTablet) {
-        runtime.Send(new IEventHandle(MakeTabletResolverID(), sender,
-            new TEvTabletResolver::TEvForward(tabletId, new IEventHandle(TActorId(), sender, ev), { },
+        runtime.Send(new IEventHandleFat(MakeTabletResolverID(), sender,
+            new TEvTabletResolver::TEvForward(tabletId, new IEventHandleFat(TActorId(), sender, ev), { },
                 sysTablet ? TEvTabletResolver::TEvForward::EActor::SysTablet : TEvTabletResolver::TEvForward::EActor::Tablet)), nodeIndex);
     }
 
     void InvalidateTabletResolverCache(TTestActorRuntime &runtime, ui64 tabletId, ui32 nodeIndex) {
-        runtime.Send(new IEventHandle(MakeTabletResolverID(), TActorId(),
+        runtime.Send(new IEventHandleFat(MakeTabletResolverID(), TActorId(),
             new TEvTabletResolver::TEvTabletProblem(tabletId, TActorId())), nodeIndex);
     }
 
@@ -709,7 +709,7 @@ namespace NKikimr {
         pipeConfig.RetryPolicy = NTabletPipe::TClientRetryPolicy::WithRetries();
 
         //get NodesInfo, nodes hostname and port are interested
-        runtime.Send(new IEventHandle(GetNameserviceActorId(), sender, new TEvInterconnect::TEvListNodes));
+        runtime.Send(new IEventHandleFat(GetNameserviceActorId(), sender, new TEvInterconnect::TEvListNodes));
         TAutoPtr<IEventHandle> handleNodesInfo;
         auto nodesInfo = runtime.GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(handleNodesInfo);
         auto bsConfigureRequest = MakeHolder<TEvBlobStorage::TEvControllerConfigRequest>();
@@ -1045,7 +1045,7 @@ namespace NKikimr {
 
     ui64 GetFreePDiskSize(TTestActorRuntime& runtime, const TActorId& sender) {
         TActorId pdiskServiceId = MakeBlobStoragePDiskID(runtime.GetNodeId(0), 0);
-        runtime.Send(new IEventHandle(pdiskServiceId, sender, nullptr));
+        runtime.Send(new IEventHandleFat(pdiskServiceId, sender, nullptr));
         TAutoPtr<IEventHandle> handle;
         auto event = runtime.GrabEdgeEvent<NMon::TEvHttpInfoRes>(handle);
         UNIT_ASSERT(event);
@@ -1071,7 +1071,7 @@ namespace NKikimr {
     }
 
     void WaitScheduledEvents(TTestActorRuntime &runtime, TDuration delay, const TActorId &sender, ui32 nodeIndex) {
-        runtime.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), delay, nodeIndex);
+        runtime.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), delay, nodeIndex);
         TAutoPtr<IEventHandle> handle;
         runtime.GrabEdgeEvent<TEvents::TEvWakeup>(handle);
     }
diff --git a/ydb/core/testlib/tenant_runtime.cpp b/ydb/core/testlib/tenant_runtime.cpp
index 90d1abfef55..737730ced3e 100644
--- a/ydb/core/testlib/tenant_runtime.cpp
+++ b/ydb/core/testlib/tenant_runtime.cpp
@@ -961,7 +961,7 @@ void TTenantTestRuntime::Setup(bool createTenantPools)
 
         // Get list of nodes to reveal IC ports.
 
-        Send(new IEventHandle(GetNameserviceActorId(), Sender, new TEvInterconnect::TEvListNodes));
+        Send(new IEventHandleFat(GetNameserviceActorId(), Sender, new TEvInterconnect::TEvListNodes));
         TAutoPtr<IEventHandle> handle;
         auto reply1 = GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(handle);
 
@@ -1153,7 +1153,7 @@ void CheckTenantPoolStatus(TTenantTestRuntime &runtime, ui32 domain,
                            THashMap<TString, NKikimrTenantPool::TSlotStatus> status,
                            ui32 nodeId)
 {
-    runtime.Send(new IEventHandle(MakeTenantPoolID(runtime.GetNodeId(nodeId), domain),
+    runtime.Send(new IEventHandleFat(MakeTenantPoolID(runtime.GetNodeId(nodeId), domain),
                                   runtime.Sender,
                                   new TEvTenantPool::TEvGetStatus));
     TAutoPtr<IEventHandle> handle;
diff --git a/ydb/core/testlib/test_client.cpp b/ydb/core/testlib/test_client.cpp
index b3038e1d886..de7607c7e86 100644
--- a/ydb/core/testlib/test_client.cpp
+++ b/ydb/core/testlib/test_client.cpp
@@ -527,7 +527,7 @@ namespace Tests {
         pipeConfig.RetryPolicy = NTabletPipe::TClientRetryPolicy::WithRetries();
 
         //get NodesInfo, nodes hostname and port are interested
-        Runtime->Send(new IEventHandle(GetNameserviceActorId(), sender, new TEvInterconnect::TEvListNodes));
+        Runtime->Send(new IEventHandleFat(GetNameserviceActorId(), sender, new TEvInterconnect::TEvListNodes));
         TAutoPtr<IEventHandle> handleNodesInfo;
         auto nodesInfo = Runtime->GrabEdgeEventRethrow<TEvInterconnect::TEvNodesInfo>(handleNodesInfo);
 
@@ -635,7 +635,7 @@ namespace Tests {
     void TServer::DestroyDynamicLocalService(ui32 nodeIdx) {
         Y_VERIFY(nodeIdx >= StaticNodes());
         TActorId local = MakeLocalID(Runtime->GetNodeId(nodeIdx)); // MakeTenantPoolRootID?
-        Runtime->Send(new IEventHandle(local, TActorId(), new TEvents::TEvPoisonPill()));
+        Runtime->Send(new IEventHandleFat(local, TActorId(), new TEvents::TEvPoisonPill()));
     }
 
     void TServer::SetupLocalConfig(TLocalConfig &localConfig, const NKikimr::TAppData &appData) {
@@ -760,7 +760,7 @@ namespace Tests {
                 Settings->AppConfig.GetTableServiceConfig().GetResourceManager(), nullptr, {}, kqpProxySharedResources);
             TActorId kqpRmServiceId = Runtime->Register(kqpRmService, nodeIdx);
             Runtime->RegisterService(NKqp::MakeKqpRmServiceID(Runtime->GetNodeId(nodeIdx)), kqpRmServiceId, nodeIdx);
-            
+
             IActor* kqpProxyService = NKqp::CreateKqpProxyService(Settings->AppConfig.GetLogConfig(),
                                                                   Settings->AppConfig.GetTableServiceConfig(),
                                                                   TVector<NKikimrKqp::TKqpSetting>(Settings->KqpSettings),
@@ -1852,10 +1852,9 @@ namespace Tests {
         entry.Path = SplitPath(path);
         entry.Operation = NSchemeCache::TSchemeCacheNavigate::OpPath;
         runtime->Send(
-            new IEventHandle(
-                MakeSchemeCacheID(),
-                sender,
-                new TEvTxProxySchemeCache::TEvNavigateKeySet(request.Release())),
+            MakeSchemeCacheID(),
+            sender,
+            new TEvTxProxySchemeCache::TEvNavigateKeySet(request.Release()),
             nodeIdx);
         auto ev = runtime->GrabEdgeEvent<TEvTxProxySchemeCache::TEvNavigateKeySetResult>(sender);
         Y_VERIFY(ev);
@@ -2264,7 +2263,7 @@ namespace Tests {
             }
         } catch (TEmptyEventQueueException &) {}
 
-        runtime->Send(new IEventHandle(pipeClient, TActorId(), new TEvents::TEvPoisonPill()));
+        runtime->Send(new IEventHandleFat(pipeClient, TActorId(), new TEvents::TEvPoisonPill()));
         return res;
     }
 
@@ -2309,7 +2308,7 @@ namespace Tests {
             }
         } catch (TEmptyEventQueueException &) {}
 
-        runtime->Send(new IEventHandle(pipeClient, edge, new TEvents::TEvPoisonPill()));
+        runtime->Send(new IEventHandleFat(pipeClient, edge, new TEvents::TEvPoisonPill()));
         return res;
     }
 
@@ -2430,7 +2429,7 @@ namespace Tests {
 
         TAutoPtr<IEventHandle> handle;
         runtime->GrabEdgeEvent<NKesus::TEvKesus::TEvGetConfigResult>(handle);
-        return handle->Release<NKesus::TEvKesus::TEvGetConfigResult>();
+        return THolder<NKesus::TEvKesus::TEvGetConfigResult>(IEventHandle::Release<NKesus::TEvKesus::TEvGetConfigResult>(handle));
     }
 
     bool IsServerRedirected() {
diff --git a/ydb/core/tx/columnshard/blob_cache.cpp b/ydb/core/tx/columnshard/blob_cache.cpp
index 59215b83309..d798cfbbc0b 100644
--- a/ydb/core/tx/columnshard/blob_cache.cpp
+++ b/ydb/core/tx/columnshard/blob_cache.cpp
@@ -176,8 +176,8 @@ private:
             HFunc(TEvColumnShard::TEvReadBlobRangesResult, Handle);
         default:
             LOG_S_WARN("Unhandled event type: " << ev->GetTypeRewrite()
-                       << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
-            ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+                       << " event: " << ev->ToString());
+            ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
             break;
         };
     }
@@ -665,12 +665,12 @@ NActors::IActor* CreateBlobCache(ui64 maxBytes, TIntrusivePtr<::NMonitoring::TDy
 
 void AddRangeToCache(const TBlobRange& blobRange, const TString& data) {
     TlsActivationContext->Send(
-        new IEventHandle(MakeBlobCacheServiceId(), TActorId(), new TEvBlobCache::TEvCacheBlobRange(blobRange, data)));
+        new IEventHandleFat(MakeBlobCacheServiceId(), TActorId(), new TEvBlobCache::TEvCacheBlobRange(blobRange, data)));
 }
 
 void ForgetBlob(const TUnifiedBlobId& blobId) {
     TlsActivationContext->Send(
-        new IEventHandle(MakeBlobCacheServiceId(), TActorId(), new TEvBlobCache::TEvForgetBlob(blobId)));
+        new IEventHandleFat(MakeBlobCacheServiceId(), TActorId(), new TEvBlobCache::TEvForgetBlob(blobId)));
 }
 
 }
diff --git a/ydb/core/tx/columnshard/columnshard__scan.cpp b/ydb/core/tx/columnshard/columnshard__scan.cpp
index 0d7f3058802..706594ad1a4 100644
--- a/ydb/core/tx/columnshard/columnshard__scan.cpp
+++ b/ydb/core/tx/columnshard/columnshard__scan.cpp
@@ -76,7 +76,7 @@ public:
         ScanActorId = ctx.SelfID;
 
         TimeoutActorId = CreateLongTimer(ctx, Deadline - TInstant::Now(),
-            new IEventHandle(SelfId(), SelfId(), new TEvents::TEvWakeup));
+            new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvWakeup));
 
         Y_VERIFY(!ScanIterator);
         ScanIterator = ReadMetadataRanges[ReadMetadataIndex]->StartScan();
diff --git a/ydb/core/tx/columnshard/columnshard_impl.h b/ydb/core/tx/columnshard/columnshard_impl.h
index ab0b1af3f0f..e7e8ba14dac 100644
--- a/ydb/core/tx/columnshard/columnshard_impl.h
+++ b/ydb/core/tx/columnshard/columnshard_impl.h
@@ -197,8 +197,8 @@ protected:
         default:
             LOG_S_WARN("TColumnShard.StateBroken at " << TabletID()
                        << " unhandled event type: " << ev->GetTypeRewrite()
-                       << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
-            ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+                       << " event: " << ev->ToString());
+            ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
             break;
         }
     }
@@ -234,7 +234,7 @@ protected:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_S_WARN("TColumnShard.StateWork at " << TabletID()
                            << " unhandled event type: "<< ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
             }
             break;
         }
diff --git a/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp b/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp
index 6ad34c2e276..0771ed4bf6a 100644
--- a/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp
+++ b/ydb/core/tx/columnshard/ut_rw/ut_columnshard_read_write.cpp
@@ -2092,7 +2092,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
             auto scanActorId = ActorIdFromProto(msg.GetScanActorId());
 
             ui32 resultLimit = 1024 * 1024;
-            runtime.Send(new IEventHandle(scanActorId, sender, new NKqp::TEvKqpCompute::TEvScanDataAck(resultLimit)));
+            runtime.Send(new IEventHandleFat(scanActorId, sender, new NKqp::TEvKqpCompute::TEvScanDataAck(resultLimit)));
             auto scan = runtime.GrabEdgeEvent<NKqp::TEvKqpCompute::TEvScanData>(handle);
             auto batchStats = scan->ArrowBatch;
             UNIT_ASSERT(batchStats);
@@ -2257,7 +2257,7 @@ Y_UNIT_TEST_SUITE(TColumnShardTestReadWrite) {
         if (ev->GetTypeRewrite() != TPrivateEvent::EventType) {
             return nullptr;
         }
-        return dynamic_cast<TPrivateEvent*>(ev->GetBase());
+        return dynamic_cast<TPrivateEvent*>(ev->StaticCastAsLocal<IEventBase>());
     }
 
     void TestCompactionGC(bool enableSmallBlobs) {
diff --git a/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp b/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp
index fe072bf9b5e..a3426017684 100644
--- a/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp
+++ b/ydb/core/tx/columnshard/ut_schema/ut_columnshard_schema.cpp
@@ -409,10 +409,7 @@ private:
 
     template <class TPrivateEvent>
     static TPrivateEvent* TryGetPrivateEvent(TAutoPtr<IEventHandle>& ev) {
-        if (ev->GetTypeRewrite() != TPrivateEvent::EventType) {
-            return nullptr;
-        }
-        return dynamic_cast<TPrivateEvent*>(ev->GetBase());
+        return ev->CastAsLocal<TPrivateEvent>();
     }
 
 public:
diff --git a/ydb/core/tx/coordinator/coordinator__read_step_subscriptions.cpp b/ydb/core/tx/coordinator/coordinator__read_step_subscriptions.cpp
index fed9b2c8fb6..cd0ce165b06 100644
--- a/ydb/core/tx/coordinator/coordinator__read_step_subscriptions.cpp
+++ b/ydb/core/tx/coordinator/coordinator__read_step_subscriptions.cpp
@@ -133,7 +133,7 @@ namespace NKikimr::NFlatTxCoordinator {
         }
 
         void SendViaSession(const TActorId& sessionId, const TActorId& target, IEventBase* event, ui32 flags, ui64 cookie) {
-            THolder<IEventHandle> ev = MakeHolder<IEventHandle>(target, SelfId(), event, flags, cookie);
+            THolder<IEventHandle> ev = MakeHolder<IEventHandleFat>(target, SelfId(), event, flags, cookie);
 
             if (sessionId) {
                 ev->Rewrite(TEvInterconnect::EvForward, sessionId);
diff --git a/ydb/core/tx/datashard/build_index.cpp b/ydb/core/tx/datashard/build_index.cpp
index 2be7f1cb11a..c4bb4644eb1 100644
--- a/ydb/core/tx/datashard/build_index.cpp
+++ b/ydb/core/tx/datashard/build_index.cpp
@@ -432,7 +432,7 @@ private:
                 default:
                 LOG_ERROR(ctx, NKikimrServices::TX_DATASHARD,
                           "TBuildIndexScan: StateWork unexpected event type: %" PRIx32 " event: %s",
-                          ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().c_str() : "serialized?");
+                          ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/tx/datashard/cdc_stream_scan.cpp b/ydb/core/tx/datashard/cdc_stream_scan.cpp
index 2b27c0e2d3b..219ba53e7c1 100644
--- a/ydb/core/tx/datashard/cdc_stream_scan.cpp
+++ b/ydb/core/tx/datashard/cdc_stream_scan.cpp
@@ -531,7 +531,7 @@ class TDataShard::TTxCdcStreamScanRun: public TTransactionBase<TDataShard> {
     THolder<IEventHandle> MakeResponse(const TActorContext& ctx,
             NKikimrTxDataShard::TEvCdcStreamScanResponse::EStatus status, const TString& error = {}) const
     {
-        return MakeHolder<IEventHandle>(Request->Sender, ctx.SelfID, new TEvDataShard::TEvCdcStreamScanResponse(
+        return MakeHolder<IEventHandleFat>(Request->Sender, ctx.SelfID, new TEvDataShard::TEvCdcStreamScanResponse(
             Request->Get()->Record, Self->TabletID(), status, error
         ));
     }
diff --git a/ydb/core/tx/datashard/datashard.cpp b/ydb/core/tx/datashard/datashard.cpp
index 69b124f648a..206585a7ce1 100644
--- a/ydb/core/tx/datashard/datashard.cpp
+++ b/ydb/core/tx/datashard/datashard.cpp
@@ -478,10 +478,9 @@ void TDataShard::PrepareAndSaveOutReadSets(ui64 step,
 
 void TDataShard::SendDelayedAcks(const TActorContext& ctx, TVector<THolder<IEventHandle>>& delayedAcks) const {
     for (auto& x : delayedAcks) {
-        TEvTxProcessing::TEvReadSetAck* ev = dynamic_cast<TEvTxProcessing::TEvReadSetAck*>(x->GetBase());
         LOG_DEBUG(ctx, NKikimrServices::TX_DATASHARD,
                   "Send delayed Ack RS Ack at %" PRIu64 " %s",
-                  TabletID(), ev->ToString().data());
+                  TabletID(), x->ToString().data());
         ctx.ExecutorThread.Send(x.Release());
         IncCounter(COUNTER_ACK_SENT_DELAYED);
     }
@@ -2105,7 +2104,7 @@ void TDataShard::SendWithConfirmedReadOnlyLease(
         TSendState(const TActorId& sessionId, const TActorId& target, const TActorId& src, IEventBase* event, ui64 cookie)
         {
             const ui32 flags = 0;
-            Ev = MakeHolder<IEventHandle>(target, src, event, flags, cookie);
+            Ev = MakeHolder<IEventHandleFat>(target, src, event, flags, cookie);
 
             if (sessionId) {
                 Ev->Rewrite(TEvInterconnect::EvForward, sessionId);
@@ -3606,7 +3605,7 @@ void TDataShard::Handle(TEvDataShard::TEvGetRSInfoRequest::TPtr &ev,
 
     for (auto &pr : Pipeline.GetDelayedAcks()) {
         for (auto &ack : pr.second) {
-            auto *ev = dynamic_cast<TEvTxProcessing::TEvReadSetAck*>(ack->GetBase());
+            auto *ev = ack->CastAsLocal<TEvTxProcessing::TEvReadSetAck>();
             if (ev) {
                 auto &rec = ev->Record;
                 auto &ack = *response->Record.AddDelayedRSAcks();
@@ -3870,7 +3869,7 @@ void SendViaSession(const TActorId& sessionId,
                     ui32 flags,
                     ui64 cookie)
 {
-    THolder<IEventHandle> ev = MakeHolder<IEventHandle>(target, src, event, flags, cookie);
+    THolder<IEventHandle> ev = MakeHolder<IEventHandleFat>(target, src, event, flags, cookie);
 
     if (sessionId) {
         ev->Rewrite(TEvInterconnect::EvForward, sessionId);
diff --git a/ydb/core/tx/datashard/datashard__kqp_scan.cpp b/ydb/core/tx/datashard/datashard__kqp_scan.cpp
index f04adb2952b..5669183971d 100644
--- a/ydb/core/tx/datashard/datashard__kqp_scan.cpp
+++ b/ydb/core/tx/datashard/datashard__kqp_scan.cpp
@@ -199,7 +199,7 @@ private:
         startConfig.Conf.ReadAheadHi = READAHEAD_HI;
 
         TimeoutActorId = CreateLongTimer(TlsActivationContext->AsActorContext(), Deadline - TInstant::Now(),
-            new IEventHandle(SelfId(), SelfId(), new TEvents::TEvWakeup));
+            new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvWakeup));
 
         if (Y_UNLIKELY(IsProfile())) {
             StartWaitTime = TInstant::Now();
diff --git a/ydb/core/tx/datashard/datashard__read_columns.cpp b/ydb/core/tx/datashard/datashard__read_columns.cpp
index 66cbf2c77fc..f621195aa25 100644
--- a/ydb/core/tx/datashard/datashard__read_columns.cpp
+++ b/ydb/core/tx/datashard/datashard__read_columns.cpp
@@ -152,8 +152,8 @@ public:
             Result->Record.SetErrorDescription("Scan aborted");
         }
 
-        TlsActivationContext->Send(new IEventHandle(ReplyTo, TActorId(), Result.Release()));
-        TlsActivationContext->Send(new IEventHandle(DatashardActorId, TActorId(), new TDataShard::TEvPrivate::TEvScanStats(Rows, Bytes)));
+        TlsActivationContext->Send(new IEventHandleFat(ReplyTo, TActorId(), Result.Release()));
+        TlsActivationContext->Send(new IEventHandleFat(DatashardActorId, TActorId(), new TDataShard::TEvPrivate::TEvScanStats(Rows, Bytes)));
 
         return this;
     }
diff --git a/ydb/core/tx/datashard/datashard__readset.cpp b/ydb/core/tx/datashard/datashard__readset.cpp
index 4d8a63ecb32..0bad7f64327 100644
--- a/ydb/core/tx/datashard/datashard__readset.cpp
+++ b/ydb/core/tx/datashard/datashard__readset.cpp
@@ -68,7 +68,7 @@ namespace NKikimr::NDataShard {
     }
 
     THolder<IEventHandle> TDataShard::TTxReadSet::MakeAck(const TActorContext& ctx) {
-        return THolder(new IEventHandle(Ev->Sender, ctx.SelfID,
+        return THolder(new IEventHandleFat(Ev->Sender, ctx.SelfID,
                                 new TEvTxProcessing::TEvReadSetAck(*Ev->Get(), Self->TabletID())));
     }
 
@@ -81,7 +81,7 @@ namespace NKikimr::NDataShard {
             record.GetTabletSource(),
             Self->TabletID());
         event->Record.SetFlags(NKikimrTx::TEvReadSet::FLAG_NO_DATA | NKikimrTx::TEvReadSet::FLAG_NO_ACK);
-        return THolder(new IEventHandle(Ev->Sender, ctx.SelfID, event.Release()));
+        return THolder(new IEventHandleFat(Ev->Sender, ctx.SelfID, event.Release()));
     }
 
     void TDataShard::TTxReadSet::Complete(const TActorContext &ctx) {
diff --git a/ydb/core/tx/datashard/datashard_impl.h b/ydb/core/tx/datashard/datashard_impl.h
index 983f22933c7..602dd2a5e50 100644
--- a/ydb/core/tx/datashard/datashard_impl.h
+++ b/ydb/core/tx/datashard/datashard_impl.h
@@ -2660,7 +2660,7 @@ protected:
 
     void Enqueue(STFUNC_SIG) override {
         LOG_WARN_S(ctx, NKikimrServices::TX_DATASHARD, "TDataShard::StateInit unhandled event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
     }
 
     // In this state we are not handling external pipes to datashard tablet (it's just another init phase)
@@ -2676,7 +2676,7 @@ protected:
         default:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_WARN_S(ctx, NKikimrServices::TX_DATASHARD, "TDataShard::StateInactive unhandled event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
             }
             break;
         }
@@ -2794,7 +2794,7 @@ protected:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_WARN_S(ctx, NKikimrServices::TX_DATASHARD,
                            "TDataShard::StateWork unhandled event type: "<< ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
             }
             break;
         }
@@ -2818,7 +2818,7 @@ protected:
         default:
             if (!HandleDefaultEvents(ev, ctx)) {
                 LOG_WARN_S(ctx, NKikimrServices::TX_DATASHARD, "TDataShard::StateWorkAsFollower unhandled event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
             }
             break;
         }
@@ -2833,8 +2833,8 @@ protected:
         default:
             LOG_WARN_S(ctx, NKikimrServices::TX_DATASHARD, "TDataShard::BrokenState at tablet " << TabletID()
                        << " unhandled event type: " << ev->GetTypeRewrite()
-                       << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
-            ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+                       << " event: " << ev->ToString());
+            ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
             break;
         }
     }
diff --git a/ydb/core/tx/datashard/datashard_pipeline.cpp b/ydb/core/tx/datashard/datashard_pipeline.cpp
index 075155d1a2e..655e898effc 100644
--- a/ydb/core/tx/datashard/datashard_pipeline.cpp
+++ b/ydb/core/tx/datashard/datashard_pipeline.cpp
@@ -1132,7 +1132,7 @@ void TPipeline::ProcessDisconnected(ui32 nodeId)
     for (auto &pr : ActiveOps) {
         if (pr.second->HasProcessDisconnectsFlag()) {
             auto *ev = new TDataShard::TEvPrivate::TEvNodeDisconnected(nodeId);
-            pr.second->AddInputEvent(new IEventHandle(Self->SelfId(), Self->SelfId(), ev));
+            pr.second->AddInputEvent(new IEventHandleFat(Self->SelfId(), Self->SelfId(), ev));
             AddCandidateOp(pr.second);
         }
     }
diff --git a/ydb/core/tx/datashard/datashard_repl_offsets_server.cpp b/ydb/core/tx/datashard/datashard_repl_offsets_server.cpp
index d0a5ca32d9b..39d15889230 100644
--- a/ydb/core/tx/datashard/datashard_repl_offsets_server.cpp
+++ b/ydb/core/tx/datashard/datashard_repl_offsets_server.cpp
@@ -314,8 +314,7 @@ void TDataShard::HandleByReplicationSourceOffsetsServer(STATEFN_SIG) {
     InvokeOtherActor(
         *ReplicationSourceOffsetsServer,
         &TReplicationSourceOffsetsServer::Receive,
-        ev,
-        TActivationContext::ActorContextFor(ReplicationSourceOffsetsServer->SelfId()));
+        ev);
 }
 
 } // namespace NKikimr::NDataShard
diff --git a/ydb/core/tx/datashard/datashard_subdomain_path_id.cpp b/ydb/core/tx/datashard/datashard_subdomain_path_id.cpp
index 97d6b88e94c..edcb8d63f34 100644
--- a/ydb/core/tx/datashard/datashard_subdomain_path_id.cpp
+++ b/ydb/core/tx/datashard/datashard_subdomain_path_id.cpp
@@ -25,7 +25,7 @@ public:
             // Wait up to a large delay, so requests from shards spread over time
             auto delay = TDuration::MicroSeconds(RandomNumber(MaxFindSubDomainPathIdDelay.MicroSeconds()));
             Timer = CreateLongTimer(TActivationContext::AsActorContext(), delay,
-                new IEventHandle(SelfId(), SelfId(), new TEvents::TEvWakeup));
+                new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvWakeup));
             Become(&TThis::StateSleep);
         } else {
             DelayNextRequest = true;
diff --git a/ydb/core/tx/datashard/datashard_ut_common.cpp b/ydb/core/tx/datashard/datashard_ut_common.cpp
index 67226f0f938..9748055496a 100644
--- a/ydb/core/tx/datashard/datashard_ut_common.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_common.cpp
@@ -778,7 +778,7 @@ ui64 TFakeMiniKQLProxy::Plan(ui64 stepId, const TMap<ui64, TFakeProxyTx::TPtr>&
                     break;
                 //Cerr << ">>> imm to " << shard << Endl;
                 UNIT_ASSERT(ShardActors.contains(shard));
-                THolder<IEventHandle> handle(new IEventHandle(ShardActors[shard], Tester.Sender, immEvent.Release()));
+                THolder<IEventHandle> handle(new IEventHandleFat(ShardActors[shard], Tester.Sender, immEvent.Release()));
                 runtime.Send(handle.Release());
                 immEvents.pop_front();
                 ++prevTxId;
@@ -968,7 +968,7 @@ ui64 TFakeMiniKQLProxy::Plan(ui64 stepId, const TMap<ui64, TFakeProxyTx::TPtr>&
 
                 //tx->AddProposeShardResult(shard, event);
                 if (event->Record.GetStatus() == NKikimrTxDataShard::TEvProposeTransactionResult::RESPONSE_DATA) {
-                    Tester.Runtime.Send(new IEventHandle(handle->Sender, Tester.Sender, new TEvStreamDataAck));
+                    Tester.Runtime.Send(new IEventHandleFat(handle->Sender, Tester.Sender, new TEvStreamDataAck));
                     tx->AddPlanStepShardResult(shard, event, false);
                 } else {
                     UNIT_ASSERT(event->IsComplete());
@@ -985,7 +985,7 @@ ui64 TFakeMiniKQLProxy::Plan(ui64 stepId, const TMap<ui64, TFakeProxyTx::TPtr>&
                 ev->Record.SetMessageSizeLimit(1 << 30);
                 ev->Record.SetReservedMessages(10);
                 ev->Record.SetRowLimit(1 << 20);
-                Tester.Runtime.Send(new IEventHandle(handle->Sender, Tester.Sender, ev.Release()));
+                Tester.Runtime.Send(new IEventHandleFat(handle->Sender, Tester.Sender, ev.Release()));
                 break;
             }
         }
@@ -1089,7 +1089,7 @@ static ui64 RunSchemeTx(
         sender = runtime.AllocateEdgeActor();
     }
 
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()), 0, viaActorSystem);
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()), 0, viaActorSystem);
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
     UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetStatus(), expectedStatus);
 
@@ -1222,7 +1222,7 @@ NKikimrScheme::TEvDescribeSchemeResult DescribeTable(Tests::TServer::TPtr server
     auto request = MakeHolder<TEvTxUserProxy::TEvNavigate>();
     request->Record.MutableDescribePath()->SetPath(path);
     request->Record.MutableDescribePath()->MutableOptions()->SetShowPrivateTable(true);
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
     auto reply = runtime.GrabEdgeEventRethrow<TEvSchemeShard::TEvDescribeSchemeResult>(handle);
 
     return *reply->MutableRecord();
@@ -1308,7 +1308,7 @@ void SendCreateVolatileSnapshot(
         tx->AddTables()->SetTablePath(path);
     }
     tx->SetTimeoutMs(timeout.MilliSeconds());
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
 }
 
 TRowVersion GrabCreateVolatileSnapshotResult(
@@ -1360,7 +1360,7 @@ bool RefreshVolatileSnapshot(
         }
         tx->SetSnapshotStep(snapshot.Step);
         tx->SetSnapshotTxId(snapshot.TxId);
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
     }
 
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
@@ -1386,7 +1386,7 @@ bool DiscardVolatileSnapshot(
         }
         tx->SetSnapshotStep(snapshot.Step);
         tx->SetSnapshotTxId(snapshot.TxId);
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
     }
 
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
@@ -1445,7 +1445,7 @@ TRowVersion CommitWrites(
             tx->AddTables()->SetTablePath(path);
         }
         tx->SetWriteTxId(writeTxId);
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
     }
 
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
@@ -1577,7 +1577,7 @@ ui64 AsyncAlterAddIndex(
     auto &settings = server->GetSettings();
     auto sender = runtime.AllocateEdgeActor();
 
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, new TEvTxUserProxy::TEvAllocateTxId()));
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, new TEvTxUserProxy::TEvAllocateTxId()));
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvAllocateTxIdResult>(sender);
     const auto txId = ev->Get()->TxId;
 
@@ -1614,7 +1614,7 @@ void CancelAddIndex(Tests::TServer::TPtr server, const TString& dbName, ui64 bui
     auto &settings = server->GetSettings();
     auto sender = runtime.AllocateEdgeActor();
 
-    runtime.Send(new IEventHandle(MakeTxProxyID(), sender, new TEvTxUserProxy::TEvAllocateTxId()));
+    runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, new TEvTxUserProxy::TEvAllocateTxId()));
     auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvAllocateTxIdResult>(sender);
     const auto txId = ev->Get()->TxId;
 
@@ -1713,7 +1713,7 @@ void SimulateSleep(Tests::TServer::TPtr server, TDuration duration) {
 
 void SimulateSleep(TTestActorRuntime& runtime, TDuration duration) {
     auto sender = runtime.AllocateEdgeActor();
-    runtime.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), duration);
+    runtime.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), duration);
     runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
 }
 
@@ -1730,7 +1730,7 @@ THolder<NSchemeCache::TSchemeCacheNavigate> Navigate(TTestActorRuntime& runtime,
     entry.RequestType = TNavigate::TEntry::ERequestType::ByPath;
     entry.Operation = op;
     entry.ShowPrivatePath = true;
-    runtime.Send(new IEventHandle(MakeSchemeCacheID(), sender, new TEvRequest(request.Release())));
+    runtime.Send(MakeSchemeCacheID(), sender, new TEvRequest(request.Release()));
 
     auto ev = runtime.GrabEdgeEventRethrow<TEvResponse>(sender);
     UNIT_ASSERT(ev);
@@ -1759,7 +1759,7 @@ void SendSQL(Tests::TServer::TPtr server,
 {
     auto &runtime = *server->GetRuntime();
     auto request = MakeSQLRequest(sql, dml);
-    runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+    runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
 }
 
 void ExecSQL(Tests::TServer::TPtr server,
@@ -1772,7 +1772,7 @@ void ExecSQL(Tests::TServer::TPtr server,
     TAutoPtr<IEventHandle> handle;
 
     auto request = MakeSQLRequest(sql, dml);
-    runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+    runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
     auto ev = runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(sender);
     UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetRef().GetYdbStatus(), code);
 }
@@ -2035,7 +2035,7 @@ void ResumeReadShardedTable(
         TReadShardedTableState& state)
 {
     auto& runtime = *server->GetRuntime();
-    runtime.Send(new IEventHandle(state.Worker, TActorId(), new TReadTableImpl::TEvResume()), 0, true);
+    runtime.Send(new IEventHandleFat(state.Worker, TActorId(), new TReadTableImpl::TEvResume()), 0, true);
     auto ev = runtime.GrabEdgeEventRethrow<TReadTableImpl::TEvResult>(state.Sender);
     state.Result = ev->Get()->Result;
 }
diff --git a/ydb/core/tx/datashard/datashard_ut_common_kqp.h b/ydb/core/tx/datashard/datashard_ut_common_kqp.h
index 8bfc5c5ec34..4994a66ce4d 100644
--- a/ydb/core/tx/datashard/datashard_ut_common_kqp.h
+++ b/ydb/core/tx/datashard/datashard_ut_common_kqp.h
@@ -85,7 +85,7 @@ namespace NKqpHelpers {
             THolder<NKqp::TEvKqp::TEvQueryRequest> request)
     {
         runtime.Send(
-            new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()),
+            new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()),
             0, /* via actor system */ true);
     }
 
diff --git a/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp b/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp
index fc453a4d089..0cc0ef06177 100644
--- a/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_erase_rows.cpp
@@ -800,7 +800,7 @@ Y_UNIT_TEST_SUITE(DistributedEraseTests) {
         FillPath(entry, path);
         entry.Operation = op;
         entry.ShowPrivatePath = true;
-        runtime.Send(new IEventHandle(MakeSchemeCacheID(), sender, new TEvRequest(request.Release())));
+        runtime.Send(MakeSchemeCacheID(), sender, new TEvRequest(request.Release()));
 
         auto ev = runtime.GrabEdgeEventRethrow<TEvResponse>(sender);
         UNIT_ASSERT(ev);
@@ -1287,7 +1287,7 @@ tkey = 100, key = 4
             auto ev = runtime.GrabEdgeEventRethrow<TEvResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetStatus(), status);
             UNIT_ASSERT_STRING_CONTAINS(ev->Get()->Record.GetErrorDescription(), error);
-            runtime.Send(new IEventHandle(eraser, sender, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(eraser, sender, new TEvents::TEvPoisonPill()));
 
             runtime.SetObserverFunc(prevObserver);
         };
@@ -1400,12 +1400,12 @@ tkey = 100, key = 4
         auto badRequest = [&](TEvResponse::ProtoRecordType::EStatus status, const TString& error, TRequestMaker maker) {
             const auto eraser = runtime.Register(NDataShard::CreateDistributedEraser(sender, tableId, indexes));
 
-            runtime.Send(new IEventHandle(eraser, sender, maker()), 0, true);
+            runtime.Send(new IEventHandleFat(eraser, sender, maker()), 0, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvResponse>(sender);
             UNIT_ASSERT_VALUES_EQUAL(ev->Get()->Record.GetStatus(), status);
             UNIT_ASSERT_STRING_CONTAINS(ev->Get()->Record.GetErrorDescription(), error);
 
-            runtime.Send(new IEventHandle(eraser, sender, new TEvents::TEvPoisonPill()));
+            runtime.Send(new IEventHandleFat(eraser, sender, new TEvents::TEvPoisonPill()));
         };
 
         badRequest(TEvResponse::ProtoRecordType::BAD_REQUEST, "Unknown condition", []() -> IEventBase* {
diff --git a/ydb/core/tx/datashard/datashard_ut_kqp.cpp b/ydb/core/tx/datashard/datashard_ut_kqp.cpp
index 5d6081530f0..b93ee8acfdd 100644
--- a/ydb/core/tx/datashard/datashard_ut_kqp.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_kqp.cpp
@@ -109,7 +109,7 @@ private:
                             StartedScans++;
                             if (StartedScans == 3 && !ActionDone && Counter <= 0 && !Reason) {
                                 auto edge = rt.AllocateEdgeActor(0);
-                                rt.Send(new IEventHandle(rt.GetInterconnectProxy(0, 1), edge,
+                                rt.Send(new IEventHandleFat(rt.GetInterconnectProxy(0, 1), edge,
                                     new TEvInterconnect::TEvPoisonSession), 0, true);
                                 ActionDone = true;
                             }
@@ -124,13 +124,13 @@ private:
 
                         if (Reason) {
                             auto evUndelivered = new TEvents::TEvUndelivered(event->GetTypeRewrite(), *Reason);
-                            auto handle = new IEventHandle(event->Sender, TActorId(), evUndelivered, 0, event->Cookie);
+                            auto handle = new IEventHandleFat(event->Sender, TActorId(), evUndelivered, 0, event->Cookie);
                             rt.Send(handle, 0, true);
                             ActionDone = true;
                         } else {
                             if (Counter <= 0 && StartedScans == 3 && !ActionDone) {
                                 auto edge = rt.AllocateEdgeActor(0);
-                                rt.Send(new IEventHandle(rt.GetInterconnectProxy(0, 1), edge,
+                                rt.Send(new IEventHandleFat(rt.GetInterconnectProxy(0, 1), edge,
                                     new TEvInterconnect::TEvPoisonSession), 0, true);
                                 ActionDone = true;
                             }
diff --git a/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp b/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp
index 772d1c86b7e..72d7f553e47 100644
--- a/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_kqp_errors.cpp
@@ -234,7 +234,7 @@ Y_UNIT_TEST(ProposeRequestUndelivered) {
         if (ev->GetTypeRewrite() == TEvPipeCache::TEvForward::EventType) {
             auto forwardEvent = ev.Get()->Get<TEvPipeCache::TEvForward>();
             if (forwardEvent->Ev->Type() == TEvDataShard::TEvProposeTransaction::EventType) {
-                rt.Send(new IEventHandle(ev->Sender, ev->Recipient,
+                rt.Send(new IEventHandleFat(ev->Sender, ev->Recipient,
                     new TEvPipeCache::TEvDeliveryProblem(forwardEvent->TabletId, /* NotDelivered */ true)));
                 return TTestActorRuntime::EEventAction::DROP;
             }
@@ -283,7 +283,7 @@ void TestProposeResultLost(TTestActorRuntime& runtime, TActorId client, const TS
                 if (ev->Sender.NodeId() == executer.NodeId()) {
                     ++droppedEvents;
                     // Cerr << "-- send undelivery to " << ev->Recipient << ", executer: " << executer << Endl;
-                    rt.Send(new IEventHandle(executer, ev->Sender,
+                    rt.Send(new IEventHandleFat(executer, ev->Sender,
                         new TEvPipeCache::TEvDeliveryProblem(msg->GetOrigin(), /* NotDelivered */ false)));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
diff --git a/ydb/core/tx/datashard/datashard_ut_kqp_scan.cpp b/ydb/core/tx/datashard/datashard_ut_kqp_scan.cpp
index b5d2a176ec0..6c946085636 100644
--- a/ydb/core/tx/datashard/datashard_ut_kqp_scan.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_kqp_scan.cpp
@@ -118,7 +118,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime.Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime.Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
 
@@ -126,7 +126,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                 case NKqp::TKqpComputeEvents::EvScanData: {
                     if (scans.contains(ev->Sender)) {
                         if (killedTablets.empty()) { // do only 1 kill per test
-                            runtime.Send(new IEventHandle(ev->Sender, ev->Sender, new NKqp::TEvKqpCompute::TEvKillScanTablet));
+                            runtime.Send(new IEventHandleFat(ev->Sender, ev->Sender, new NKqp::TEvKqpCompute::TEvKillScanTablet));
                             Cerr << (TStringBuilder() << "-- EvScanData from " << ev->Sender << ": hijack event, kill tablet " << ev->Sender << Endl);
                             Cerr.Flush();
                         }
@@ -215,7 +215,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime.Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime.Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
 
@@ -321,7 +321,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
 
-                    runtime.Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime.Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
 
                     return TTestActorRuntime::EEventAction::DROP;
                 }
@@ -451,7 +451,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
 
-                    runtime.Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime.Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
 
                     return TTestActorRuntime::EEventAction::DROP;
                 }
@@ -578,7 +578,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                     resp->Record.SetEnough(false);
                     resp->Record.SetSeqNo(ev->Get<NKqp::TEvKqpExecuter::TEvStreamData>()->Record.GetSeqNo());
                     resp->Record.SetFreeSpace(100);
-                    runtime.Send(new IEventHandle(ev->Sender, sender, resp.Release()));
+                    runtime.Send(new IEventHandleFat(ev->Sender, sender, resp.Release()));
                     return TTestActorRuntime::EEventAction::DROP;
                 }
 
@@ -586,7 +586,7 @@ Y_UNIT_TEST_SUITE(KqpScan) {
                 case NKqp::TKqpComputeEvents::EvScanData: {
                     if (scans.contains(ev->Sender)) {
                         if (killedTablets.empty()) { // do only 1 kill per test
-                            runtime.Send(new IEventHandle(ev->Sender, ev->Sender, new NKqp::TEvKqpCompute::TEvKillScanTablet));
+                            runtime.Send(new IEventHandleFat(ev->Sender, ev->Sender, new NKqp::TEvKqpCompute::TEvKillScanTablet));
                             Cerr << (TStringBuilder() << "-- EvScanData from " << ev->Sender << ": hijack event, kill tablet " << ev->Sender << Endl);
                             Cerr.Flush();
                         }
diff --git a/ydb/core/tx/datashard/datashard_ut_locks.cpp b/ydb/core/tx/datashard/datashard_ut_locks.cpp
index b334d4400f7..8f48b29ec9d 100644
--- a/ydb/core/tx/datashard/datashard_ut_locks.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_locks.cpp
@@ -616,7 +616,7 @@ void CheckLocksCacheUsage(bool waitForLocksStore) {
         desc.AddKeyColumnNames("key");
         desc.SetUniformPartitionsCount(2);
 
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
         auto reply = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(handle);
         UNIT_ASSERT_VALUES_EQUAL(reply->Record.GetStatus(), TEvTxUserProxy::TEvProposeTransactionStatus::EStatus::ExecInProgress);
         txId = reply->Record.GetTxId();
@@ -630,20 +630,20 @@ void CheckLocksCacheUsage(bool waitForLocksStore) {
 
     {
         auto request = MakeSQLRequest("UPSERT INTO `/Root/table-1` (key, value) VALUES (1,0x80000002),(0x80000001,2)");
-        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
         runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
     }
 
     {
         auto request = MakeSQLRequest("UPSERT INTO `/Root/table-1` (key, value) SELECT value as key, value FROM `/Root/table-1`");
-        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
 
         // Get shard IDs.
         ui64 shards[2];
         {
             auto request = MakeHolder<TEvTxUserProxy::TEvNavigate>();
             request->Record.MutableDescribePath()->SetPath("/Root/table-1");
-            runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+            runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
             auto reply = runtime.GrabEdgeEventRethrow<TEvSchemeShard::TEvDescribeSchemeResult>(handle);
             for (auto i = 0; i < 2; ++i)
                 shards[i] = reply->GetRecord().GetPathDescription()
@@ -702,7 +702,7 @@ void CheckLocksCacheUsage(bool waitForLocksStore) {
 
     {
         auto request = MakeSQLRequest("SELECT * FROM `/Root/table-1`");
-        runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
         auto reply = runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
         auto &resp = reply->Record.GetRef().GetResponse();
         UNIT_ASSERT_VALUES_EQUAL(resp.ResultsSize(), 1);
diff --git a/ydb/core/tx/datashard/datashard_ut_minstep.cpp b/ydb/core/tx/datashard/datashard_ut_minstep.cpp
index 64c87648381..15d0acfe9df 100644
--- a/ydb/core/tx/datashard/datashard_ut_minstep.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_minstep.cpp
@@ -366,7 +366,7 @@ Y_UNIT_TEST_SUITE(TDataShardMinStepTest) {
             auto event = new TEvDataShard::TEvProposeTransaction;
             event->Record = proposeRecord;
             ActorIdToProto(sender, event->Record.MutableSource());
-            runtime.Send(new IEventHandle(shardActorId, sender, event), 0, true);
+            runtime.Send(new IEventHandleFat(shardActorId, sender, event), 0, true);
         }
 
         Cerr << "Waiting for propose echo reply..." << Endl;
diff --git a/ydb/core/tx/datashard/datashard_ut_order.cpp b/ydb/core/tx/datashard/datashard_ut_order.cpp
index 4f6012ba5ed..7866e36a316 100644
--- a/ydb/core/tx/datashard/datashard_ut_order.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_order.cpp
@@ -1267,7 +1267,7 @@ Y_UNIT_TEST(TestDelayedTxWaitsForWriteActiveTxOnly) {
         auto &tx = *req->Record.MutableTransaction()->MutableReadTableTransaction();
         tx.SetPath("/Root/table-2");
 
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, req));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, req));
         runtime.GrabEdgeEventRethrow<TEvTxProcessing::TEvStreamQuotaRequest>(handle);
     }
 
@@ -1343,7 +1343,7 @@ Y_UNIT_TEST(TestOnlyDataTxLagCausesRejects) {
         req->Record.SetStreamResponse(true);
         auto &tx = *req->Record.MutableTransaction()->MutableReadTableTransaction();
         tx.SetPath("/Root/table-1");
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, req));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, req));
         runtime.GrabEdgeEventRethrow<TEvTxProcessing::TEvStreamQuotaRequest>(handle);
     }
 
@@ -1475,7 +1475,7 @@ Y_UNIT_TEST_TWIN(TestOutOfOrderLockLost, StreamLookup) {
     // Schedule a simple timer to simulate some time passing
     {
         auto sender4 = runtime.AllocateEdgeActor();
-        runtime.Schedule(new IEventHandle(sender4, sender4, new TEvents::TEvWakeup()), TDuration::Seconds(1));
+        runtime.Schedule(new IEventHandleFat(sender4, sender4, new TEvents::TEvWakeup()), TDuration::Seconds(1));
         runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender4);
     }
 
@@ -2615,7 +2615,7 @@ Y_UNIT_TEST(TestPlannedCancelSplit) {
                 msg->GetTxId(),
                 NKikimrTxDataShard::TEvProposeTransactionResult::OVERLOADED);
             Cerr << "Sending error result from " << actors[1] << " to " << target << Endl;
-            runtime.Send(new IEventHandle(target, actors[1], result), 0, /* via actor system */ true);
+            runtime.Send(new IEventHandleFat(target, actors[1], result), 0, /* via actor system */ true);
             event.Reset(); // drop this propose event
         }
     }
@@ -2938,7 +2938,7 @@ namespace {
         tx.AddColumns("key");
         tx.AddColumns("value");
 
-        runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+        runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
     }
 
 }
@@ -3265,7 +3265,7 @@ Y_UNIT_TEST(TestImmediateQueueThenSplit) {
             case EventSpaceBegin(TKikimrEvents::ES_PRIVATE) + 2 /* EvDelayedProposeTransaction */:
                 if (captureDelayedProposeFrom.contains(event->GetRecipientRewrite())) {
                     Cerr << "---- capture EvDelayedProposeTransaction ----" << Endl;
-                    Cerr << event->GetBase()->ToString() << Endl;
+                    Cerr << event->GetTypeName() << Endl;
                     eventsDelayedPropose.emplace_back(event.Release());
                     return TTestActorRuntime::EEventAction::DROP;
                 }
@@ -4406,7 +4406,7 @@ Y_UNIT_TEST_TWIN(TestSnapshotReadPriority, UnprotectedReads) {
         Cerr << "!!! Setting up wakeup spam" << Endl;
         auto senderWakeupSpam = runtime.AllocateEdgeActor();
         for (int i = 1; i <= 10; ++i) {
-            runtime.Schedule(new IEventHandle(senderWakeupSpam, senderWakeupSpam, new TEvents::TEvWakeup()), TDuration::MicroSeconds(i * 250));
+            runtime.Schedule(new IEventHandleFat(senderWakeupSpam, senderWakeupSpam, new TEvents::TEvWakeup()), TDuration::MicroSeconds(i * 250));
         }
     }
 
@@ -4484,7 +4484,7 @@ Y_UNIT_TEST_TWIN(TestSnapshotReadPriority, UnprotectedReads) {
         Cerr << "!!! Setting up wakeup spam" << Endl;
         auto senderWakeupSpam = runtime.AllocateEdgeActor();
         for (int i = 1; i <= 10; ++i) {
-            runtime.Schedule(new IEventHandle(senderWakeupSpam, senderWakeupSpam, new TEvents::TEvWakeup()), TDuration::MicroSeconds(i * 250));
+            runtime.Schedule(new IEventHandleFat(senderWakeupSpam, senderWakeupSpam, new TEvents::TEvWakeup()), TDuration::MicroSeconds(i * 250));
         }
     }
 
@@ -4563,7 +4563,7 @@ Y_UNIT_TEST_TWIN(TestSnapshotReadPriority, UnprotectedReads) {
         Cerr << "!!! Setting up wakeup spam" << Endl;
         auto senderWakeupSpam = runtime.AllocateEdgeActor();
         for (int i = 1; i <= 10; ++i) {
-            runtime.Schedule(new IEventHandle(senderWakeupSpam, senderWakeupSpam, new TEvents::TEvWakeup()), TDuration::MicroSeconds(i * 250));
+            runtime.Schedule(new IEventHandleFat(senderWakeupSpam, senderWakeupSpam, new TEvents::TEvWakeup()), TDuration::MicroSeconds(i * 250));
         }
     }
 
@@ -4683,7 +4683,7 @@ Y_UNIT_TEST(TestUnprotectedReadsThenWriteVisibility) {
                                 update->Record.SetMediator(mediatorId);
                                 update->Record.SetBucket(bucket);
                                 update->Record.SetTimeBarrier(passedStep);
-                                runtime.Send(new IEventHandle(ev->GetRecipientRewrite(), ev->GetRecipientRewrite(), update), nodeIndex, /* viaActorSystem */ true);
+                                runtime.Send(new IEventHandleFat(ev->GetRecipientRewrite(), ev->GetRecipientRewrite(), update), nodeIndex, /* viaActorSystem */ true);
                             }
                         }
                     }
@@ -4997,7 +4997,7 @@ Y_UNIT_TEST(UncommittedReadSetAck) {
         auto proxy = ev->Recipient;
         ui32 groupId = GroupIDFromBlobStorageProxyID(proxy);
         auto res = ev->Get<TEvBlobStorage::TEvPut>()->MakeErrorResponse(NKikimrProto::ERROR, "Something went wrong", groupId);
-        runtime.Send(new IEventHandle(ev->Sender, proxy, res.release()), 1, true);
+        runtime.Send(new IEventHandleFat(ev->Sender, proxy, res.release()), 1, true);
     }
     capturedCommits.clear();
 
diff --git a/ydb/core/tx/datashard/datashard_ut_read_iterator.cpp b/ydb/core/tx/datashard/datashard_ut_read_iterator.cpp
index 4cd0e9209f1..1711b34e6d0 100644
--- a/ydb/core/tx/datashard/datashard_ut_read_iterator.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_read_iterator.cpp
@@ -432,7 +432,7 @@ struct TTestHelper {
             TAutoPtr<IEventHandle> handle;
             runtime.GrabEdgeEventRethrow<TEvDataShard::TEvUploadRowsResponse>(handle);
             UNIT_ASSERT(handle);
-            auto event = handle->Release<TEvDataShard::TEvUploadRowsResponse>();
+            auto event = handle->CastAsLocal<TEvDataShard::TEvUploadRowsResponse>();
             UNIT_ASSERT(event->Record.GetStatus() == 0);
         }
     }
@@ -514,8 +514,8 @@ struct TTestHelper {
         if (!handle) {
             return nullptr;
         }
-        auto event = handle->Release<TEvDataShard::TEvReadResult>();
-        return std::unique_ptr<TEvDataShard::TEvReadResult>(event.Release());
+        std::unique_ptr<TEvDataShard::TEvReadResult> event(IEventHandle::Release<TEvDataShard::TEvReadResult>(handle));
+        return event;
     }
 
     std::unique_ptr<TEvDataShard::TEvReadResult> SendRead(
@@ -2112,7 +2112,7 @@ Y_UNIT_TEST_SUITE(DataShardReadIterator) {
 
         // now allow to continue read
         shouldDrop = false;
-        TAutoPtr<TEvDataShard::TEvReadContinue> request = continueEvent->Release<TEvDataShard::TEvReadContinue>();
+        TAutoPtr<TEvDataShard::TEvReadContinue> request = IEventHandle::Release<TEvDataShard::TEvReadContinue>(continueEvent);
         UNIT_ASSERT_VALUES_EQUAL(request->ReadId, 1UL);
 
         const auto& table = helper.Tables["table-1"];
@@ -2206,7 +2206,7 @@ Y_UNIT_TEST_SUITE(DataShardReadIterator) {
 
         // now allow to continue read and check we don't get extra read result with error
         shouldDrop = false;
-        TAutoPtr<TEvDataShard::TEvReadContinue> request = continueEvent->Release<TEvDataShard::TEvReadContinue>();
+        TAutoPtr<TEvDataShard::TEvReadContinue> request = IEventHandle::Release<TEvDataShard::TEvReadContinue>(continueEvent);
         UNIT_ASSERT_VALUES_EQUAL(request->ReadId, 1UL);
 
         const auto& table = helper.Tables["table-1"];
@@ -2325,7 +2325,7 @@ Y_UNIT_TEST_SUITE(DataShardReadIterator) {
                 ++continueCounter;
                 break;
             case TEvTabletPipe::EvServerConnected: {
-                auto* typedEvent = dynamic_cast<TEvTabletPipe::TEvServerConnected*>(ev->GetBase());
+                auto* typedEvent = ev->CastAsLocal<TEvTabletPipe::TEvServerConnected>();
                 ++serverConnectedCount;
                 if (typedEvent->ClientId.NodeId() != typedEvent->ServerId.NodeId()) {
                     connectedFromDifferentNode = true;
diff --git a/ydb/core/tx/datashard/datashard_ut_read_table.h b/ydb/core/tx/datashard/datashard_ut_read_table.h
index bda4bd1000a..e9794bf7311 100644
--- a/ydb/core/tx/datashard/datashard_ut_read_table.h
+++ b/ydb/core/tx/datashard/datashard_ut_read_table.h
@@ -214,7 +214,7 @@ namespace NDataShardReadTableTest {
 
         bool Next() {
             if (!Finished) {
-                Runtime.Send(new IEventHandle(Driver, TActorId(), new TReadTableDriver::TEvNext()), 0, true);
+                Runtime.Send(new IEventHandleFat(Driver, TActorId(), new TReadTableDriver::TEvNext()), 0, true);
                 auto ev = Runtime.GrabEdgeEventRethrow<TReadTableDriver::TEvResult>(Edge);
                 LastResult = ev->Get()->Result;
                 Finished = ev->Get()->Finished;
diff --git a/ydb/core/tx/datashard/datashard_ut_rs.cpp b/ydb/core/tx/datashard/datashard_ut_rs.cpp
index b71bea89218..4308b60c1c4 100644
--- a/ydb/core/tx/datashard/datashard_ut_rs.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_rs.cpp
@@ -83,7 +83,7 @@ Y_UNIT_TEST_SUITE(TDataShardRSTest) {
         // Fill some data. Later we will copy data from shards 2 and 3 to shard 1.
         {
             auto request = MakeSQLRequest("UPSERT INTO `/Root/table-1` (key, value) VALUES (0x50000000,1),(0x80000001,1),(0x80000002,1),(0x80000003,1),(0x80000004,1),(0x80000005,1),(0x80000006,1),(0x80000007,1),(0x80000008,1),(0x80000009,1)");
-            runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+            runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
             runtime.GrabEdgeEventRethrow<NKqp::TEvKqp::TEvQueryResponse>(handle);
         }
 
@@ -121,7 +121,7 @@ Y_UNIT_TEST_SUITE(TDataShardRSTest) {
             runtime.SetObserverFunc(captureRS);
 
             auto request = MakeSQLRequest("UPSERT INTO `/Root/table-1` (key, value) SELECT value, key FROM `/Root/table-1` WHERE key = 0x50000000");
-            runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+            runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
             // Wait until both parts of tx are finished on the second shard.
             TDispatchOptions options;
             options.FinalEvents.emplace_back(IsTxResultComplete(), 2);
@@ -132,7 +132,7 @@ Y_UNIT_TEST_SUITE(TDataShardRSTest) {
         {
             for (auto i = 1; i < 10; ++i) {
                 auto request = MakeSQLRequest(Sprintf("UPSERT INTO `/Root/table-1` (key, value) SELECT value, key FROM `/Root/table-1` WHERE key = %" PRIu32, i + 0x80000000));
-                runtime.Send(new IEventHandle(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
+                runtime.Send(new IEventHandleFat(NKqp::MakeKqpProxyID(runtime.GetNodeId()), sender, request.Release()));
             }
             TDispatchOptions options;
             options.FinalEvents.emplace_back(TEvTxProcessing::EvReadSetAck, 9);
diff --git a/ydb/core/tx/datashard/datashard_ut_volatile.cpp b/ydb/core/tx/datashard/datashard_ut_volatile.cpp
index ac595562f03..b8d9145f426 100644
--- a/ydb/core/tx/datashard/datashard_ut_volatile.cpp
+++ b/ydb/core/tx/datashard/datashard_ut_volatile.cpp
@@ -1320,8 +1320,8 @@ Y_UNIT_TEST_SUITE(DataShardVolatile) {
                 }
                 default: {
                     Cerr << "... ignored event " << ev->GetTypeRewrite();
-                    if (ev->GetBase()) {
-                        Cerr << " " << ev->GetBase()->ToString();
+                    if (ev->HasEvent()) {
+                        Cerr << " " << ev->GetTypeName();
                     }
                     Cerr << Endl;
                 }
diff --git a/ydb/core/tx/datashard/read_table_scan.cpp b/ydb/core/tx/datashard/read_table_scan.cpp
index 9b12fe7ac74..cea198b4351 100644
--- a/ydb/core/tx/datashard/read_table_scan.cpp
+++ b/ydb/core/tx/datashard/read_table_scan.cpp
@@ -342,7 +342,7 @@ public:
         default:
             LOG_ERROR(ctx, NKikimrServices::TX_DATASHARD,
                       "TReadTableScan: StateWork unexpected event type: %" PRIx32 " event: %s",
-                      ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                      ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/tx/datashard/read_table_scan_unit.cpp b/ydb/core/tx/datashard/read_table_scan_unit.cpp
index 9fc30ad9d29..6d0630ea00e 100644
--- a/ydb/core/tx/datashard/read_table_scan_unit.cpp
+++ b/ydb/core/tx/datashard/read_table_scan_unit.cpp
@@ -206,7 +206,7 @@ void TReadTableScanUnit::ProcessEvent(TAutoPtr<NActors::IEventHandle> &ev,
     default:
         LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD,
                     "TReadTableScanUnit::ProcessEvent unhandled event type: " << ev->GetTypeRewrite()
-                    << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                    << " event: " << ev->ToString());
         Y_VERIFY_DEBUG(false, "unexpected event %" PRIu64, (ui64)ev->GetTypeRewrite());
     }
 }
diff --git a/ydb/core/tx/datashard/wait_for_stream_clearance_unit.cpp b/ydb/core/tx/datashard/wait_for_stream_clearance_unit.cpp
index db91ceb7fc6..3f38f0932e1 100644
--- a/ydb/core/tx/datashard/wait_for_stream_clearance_unit.cpp
+++ b/ydb/core/tx/datashard/wait_for_stream_clearance_unit.cpp
@@ -125,7 +125,7 @@ void TWaitForStreamClearanceUnit::ProcessEvent(TAutoPtr<NActors::IEventHandle> &
     default:
         LOG_ERROR_S(ctx, NKikimrServices::TX_DATASHARD,
                     "TWaitForStreamClearanceUnit::ProcessEvent unhandled event type: " << ev->GetTypeRewrite()
-                    << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                    << " event: " << ev->ToString());
         Y_VERIFY_DEBUG(false, "unexpected event %" PRIu64, (ui64)ev->GetTypeRewrite());
     }
 }
diff --git a/ydb/core/tx/long_tx_service/commit_impl.cpp b/ydb/core/tx/long_tx_service/commit_impl.cpp
index 91e082f962d..c151affbc23 100644
--- a/ydb/core/tx/long_tx_service/commit_impl.cpp
+++ b/ydb/core/tx/long_tx_service/commit_impl.cpp
@@ -109,7 +109,7 @@ namespace NLongTxService {
                 ++data.NumRetries;
                 if (ToRetry.empty()) {
                     TimeoutTimerActorId = CreateLongTimer(TDuration::MilliSeconds(TRetryData::RetryDelayMs),
-                        new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup()));
+                        new IEventHandleFat(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup()));
                 }
                 ToRetry.insert(tabletId);
                 return true;
@@ -413,7 +413,7 @@ namespace NLongTxService {
 
                 if (ToRetry.empty()) {
                     TimeoutTimerActorId = CreateLongTimer(TDuration::MilliSeconds(TRetryData::RetryDelayMs),
-                        new IEventHandle(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup()));
+                        new IEventHandleFat(this->SelfId(), this->SelfId(), new TEvents::TEvWakeup()));
                 }
                 ToRetry.insert(tabletId);
                 return true;
diff --git a/ydb/core/tx/long_tx_service/long_tx_service_impl.cpp b/ydb/core/tx/long_tx_service/long_tx_service_impl.cpp
index 11b74196c27..800a7282c06 100644
--- a/ydb/core/tx/long_tx_service/long_tx_service_impl.cpp
+++ b/ydb/core/tx/long_tx_service/long_tx_service_impl.cpp
@@ -718,7 +718,7 @@ void TLongTxServiceActor::Handle(TEvLongTxService::TEvUnsubscribeLock::TPtr& ev)
 void TLongTxServiceActor::SendViaSession(const TActorId& sessionId, const TActorId& recipient,
         IEventBase* event, ui32 flags, ui64 cookie)
 {
-    auto ev = MakeHolder<IEventHandle>(recipient, SelfId(), event, flags, cookie);
+    auto ev = MakeHolder<IEventHandleFat>(recipient, SelfId(), event, flags, cookie);
     if (sessionId) {
         ev->Rewrite(TEvInterconnect::EvForward, sessionId);
     }
@@ -785,13 +785,20 @@ void TLongTxServiceActor::SendProxyRequest(ui32 nodeId, ERequestType type, THold
     THolder<IEventHandle> pendingEv;
     auto target = MakeLongTxServiceID(nodeId);
     auto flags = IEventHandle::FlagTrackDelivery;
-    if (ev->HasBuffer()) {
-        auto type = ev->GetTypeRewrite();
-        auto buffer = ev->ReleaseChainBuffer();
-        pendingEv.Reset(new IEventHandle(type, flags, target, SelfId(), std::move(buffer), cookie));
+    if (ev->IsEventFat()) {
+        auto* evf = IEventHandleFat::GetFat(ev);
+        if (evf->HasBuffer()) {
+            auto type = evf->GetTypeRewrite();
+            auto buffer = evf->ReleaseChainBuffer();
+            pendingEv.Reset(new IEventHandleFat(type, flags, target, SelfId(), std::move(buffer), cookie));
+        } else {
+            auto event = evf->ReleaseBase();
+            pendingEv.Reset(new IEventHandleFat(target, SelfId(), event.Release(), flags, cookie));
+        }
     } else {
-        auto event = ev->ReleaseBase();
-        pendingEv.Reset(new IEventHandle(target, SelfId(), event.Release(), flags, cookie));
+        auto* evl = IEventHandleLight::GetLight(ev);
+        evl->PrepareSend(target, SelfId(), flags);
+        pendingEv = std::move(ev);
     }
     Y_VERIFY(pendingEv->Recipient.NodeId() == nodeId);
 
diff --git a/ydb/core/tx/long_tx_service/long_tx_service_ut.cpp b/ydb/core/tx/long_tx_service/long_tx_service_ut.cpp
index 45545651b93..c565d7a747f 100644
--- a/ydb/core/tx/long_tx_service/long_tx_service_ut.cpp
+++ b/ydb/core/tx/long_tx_service/long_tx_service_ut.cpp
@@ -72,7 +72,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
 
         void SimulateSleep(TTestActorRuntime& runtime, TDuration duration) {
             auto sender = runtime.AllocateEdgeActor();
-            runtime.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), duration);
+            runtime.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), duration);
             runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
         }
 
@@ -92,7 +92,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Begin a new transaction at node 1
         {
             runtime.Send(
-                new IEventHandle(service1, sender1,
+                new IEventHandleFat(service1, sender1,
                     new TEvLongTxService::TEvBeginTx("/dc-1",
                         NKikimrLongTxService::TEvBeginTx::MODE_WRITE_ONLY)),
                 0, true);
@@ -106,7 +106,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Issue an empty attach message at node 2
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvAttachColumnShardWrites(txId)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvAttachColumnShardWritesResult>(sender2);
@@ -117,7 +117,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Commit this transaction at node 2
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvCommitTx(txId)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvCommitTxResult>(sender2);
@@ -128,7 +128,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Rollback this transaction at node 2
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvRollbackTx(txId)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvRollbackTxResult>(sender2);
@@ -144,7 +144,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
                     if (node1 != node2) {
                         auto proxy = runtime.GetInterconnectProxy(0, 1);
                         runtime.Send(
-                            new IEventHandle(proxy, {}, new TEvInterconnect::TEvDisconnect()),
+                            new IEventHandleFat(proxy, {}, new TEvInterconnect::TEvDisconnect()),
                             0, true);
                         return TTestBasicRuntime::EEventAction::DROP;
                     }
@@ -158,7 +158,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Rollback this transaction at node 2
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvRollbackTx(txId)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvRollbackTxResult>(sender2);
@@ -171,7 +171,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
             auto badTxId = txId;
             badTxId.NodeId = runtime.GetNodeId(1) + 1;
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvCommitTx(badTxId)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvCommitTxResult>(sender2);
@@ -194,7 +194,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Send an acquire read snapshot for node 1
         {
             runtime.Send(
-                new IEventHandle(service1, sender1,
+                new IEventHandleFat(service1, sender1,
                     new TEvLongTxService::TEvAcquireReadSnapshot("/dc-1")),
                 0, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvAcquireReadSnapshotResult>(sender1);
@@ -205,7 +205,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Begin a new read-only transaction at node 1
         {
             runtime.Send(
-                new IEventHandle(service1, sender1,
+                new IEventHandleFat(service1, sender1,
                     new TEvLongTxService::TEvBeginTx("/dc-1",
                         NKikimrLongTxService::TEvBeginTx::MODE_READ_ONLY)),
                 0, true);
@@ -220,7 +220,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // Begin a new read-write transaction at node 1
         {
             runtime.Send(
-                new IEventHandle(service1, sender1,
+                new IEventHandleFat(service1, sender1,
                     new TEvLongTxService::TEvBeginTx("/dc-1",
                         NKikimrLongTxService::TEvBeginTx::MODE_READ_WRITE)),
                 0, true);
@@ -248,7 +248,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
 
         {
             runtime.Send(
-                new IEventHandle(service1, sender1,
+                new IEventHandleFat(service1, sender1,
                     new TEvLongTxService::TEvSubscribeLock(987, node1)),
                 0, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvLockStatus>(sender1);
@@ -260,7 +260,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
 
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvSubscribeLock(987, node1)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvLockStatus>(sender2);
@@ -272,7 +272,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
 
         {
             runtime.Send(
-                new IEventHandle(service1, sender1,
+                new IEventHandleFat(service1, sender1,
                     new TEvLongTxService::TEvSubscribeLock(123, node1)),
                 0, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvLockStatus>(sender1);
@@ -284,7 +284,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
 
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvSubscribeLock(123, node1)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvLockStatus>(sender2);
@@ -326,7 +326,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
                         ++disconnectCount;
                         auto proxy = runtime.GetInterconnectProxy(0, 1);
                         runtime.Send(
-                            new IEventHandle(proxy, {}, new TEvInterconnect::TEvDisconnect()),
+                            new IEventHandleFat(proxy, {}, new TEvInterconnect::TEvDisconnect()),
                             0, true);
                         // Advance time on each disconnect, so timeout happens faster
                         runtime.AdvanceCurrentTime(TDuration::Seconds(5));
@@ -343,7 +343,7 @@ Y_UNIT_TEST_SUITE(LongTxService) {
         // We should eventually get an unavailable result
         {
             runtime.Send(
-                new IEventHandle(service2, sender2,
+                new IEventHandleFat(service2, sender2,
                     new TEvLongTxService::TEvSubscribeLock(234, node1)),
                 1, true);
             auto ev = runtime.GrabEdgeEventRethrow<TEvLongTxService::TEvLockStatus>(sender2);
diff --git a/ydb/core/tx/mediator/execute_queue.cpp b/ydb/core/tx/mediator/execute_queue.cpp
index 25ccba52fb6..0b83516c99d 100644
--- a/ydb/core/tx/mediator/execute_queue.cpp
+++ b/ydb/core/tx/mediator/execute_queue.cpp
@@ -188,7 +188,7 @@ namespace NTxMediator {
 
         TAutoPtr<IEventHandle> AfterRegister(const TActorId &self, const TActorId& parentId) override {
             Y_UNUSED(parentId);
-            return new IEventHandle(self, self, new TEvents::TEvBootstrap());
+            return new IEventHandleFat(self, self, new TEvents::TEvBootstrap());
         }
 
         STFUNC(StateWork) {
diff --git a/ydb/core/tx/mediator/tablet_queue.cpp b/ydb/core/tx/mediator/tablet_queue.cpp
index fa05f7acd22..f0d860dfa20 100644
--- a/ydb/core/tx/mediator/tablet_queue.cpp
+++ b/ydb/core/tx/mediator/tablet_queue.cpp
@@ -128,7 +128,7 @@ class TTxMediatorTabletQueue : public TActor<TTxMediatorTabletQueue> {
             for (const TActorId &x : TimecastWatches) {
                 LOG_DEBUG_S(ctx, NKikimrServices::TX_MEDIATOR_TABLETQUEUE, "Actor# " << ctx.SelfID.ToString()
                     << " Mediator# " << Mediator << " SEND to# " << x.ToString() << " " << evx.ToString());
-                ctx.ExecutorThread.Send(new IEventHandle(TEvMediatorTimecast::TEvUpdate::EventType, sendFlags, x, ctx.SelfID, data, 0));
+                ctx.ExecutorThread.Send(new IEventHandleFat(TEvMediatorTimecast::TEvUpdate::EventType, sendFlags, x, ctx.SelfID, data, 0));
             }
         }
     }
diff --git a/ydb/core/tx/replication/controller/tx_drop_replication.cpp b/ydb/core/tx/replication/controller/tx_drop_replication.cpp
index b59e519b3b9..25619b9a9ac 100644
--- a/ydb/core/tx/replication/controller/tx_drop_replication.cpp
+++ b/ydb/core/tx/replication/controller/tx_drop_replication.cpp
@@ -51,7 +51,7 @@ public:
             ev->Record.MutableOperationId()->CopyFrom(record.GetOperationId());
             ev->Record.SetOrigin(Self->TabletID());
             ev->Record.SetStatus(NKikimrReplication::TEvDropReplicationResult::NOT_FOUND);
-            Result = MakeHolder<IEventHandle>(PubEv->Sender, ctx.SelfID, ev.Release());
+            Result = MakeHolder<IEventHandleFat>(PubEv->Sender, ctx.SelfID, ev.Release());
 
             return true;
         }
@@ -123,7 +123,7 @@ public:
             ev->Record.MutableOperationId()->SetPartId(op->OperationId.second);
             ev->Record.SetOrigin(Self->TabletID());
             ev->Record.SetStatus(NKikimrReplication::TEvDropReplicationResult::SUCCESS);
-            Result = MakeHolder<IEventHandle>(op->Sender, ctx.SelfID, ev.Release());
+            Result = MakeHolder<IEventHandleFat>(op->Sender, ctx.SelfID, ev.Release());
         }
 
         Self->Remove(rid);
diff --git a/ydb/core/tx/replication/ydb_proxy/ydb_proxy.cpp b/ydb/core/tx/replication/ydb_proxy/ydb_proxy.cpp
index 45de477068c..234a08a7556 100644
--- a/ydb/core/tx/replication/ydb_proxy/ydb_proxy.cpp
+++ b/ydb/core/tx/replication/ydb_proxy/ydb_proxy.cpp
@@ -69,7 +69,7 @@ class TBaseProxyActor: public TActor<TDerived> {
             std::lock_guard<std::mutex> lock(RWActorSystem);
 
             if (ActorSystem) {
-                ActorSystem->Send(new IEventHandle(recipient, Self, ev, 0, cookie));
+                ActorSystem->Send(new IEventHandleFat(recipient, Self, ev, 0, cookie));
             }
         }
 
diff --git a/ydb/core/tx/replication/ydb_proxy/ydb_proxy_ut.cpp b/ydb/core/tx/replication/ydb_proxy/ydb_proxy_ut.cpp
index 199cf2a359f..12677ebf027 100644
--- a/ydb/core/tx/replication/ydb_proxy/ydb_proxy_ut.cpp
+++ b/ydb/core/tx/replication/ydb_proxy/ydb_proxy_ut.cpp
@@ -92,14 +92,14 @@ Y_UNIT_TEST_SUITE(YdbProxyTests) {
                 UNIT_ASSERT(desc.GetPathDescription().GetDomainDescription().HasSecurityState());
 
                 const auto& secState = desc.GetPathDescription().GetDomainDescription().GetSecurityState();
-                Server.GetRuntime()->Send(new IEventHandle(MakeTicketParserID(), Sender,
+                Server.GetRuntime()->Send(new IEventHandleFat(MakeTicketParserID(), Sender,
                     new TEvTicketParser::TEvUpdateLoginSecurityState(secState)));
             }
         }
 
         template <typename TEvResponse>
         auto Send(IEventBase* ev) {
-            Server.GetRuntime()->Send(new IEventHandle(YdbProxy, Sender, ev));
+            Server.GetRuntime()->Send(new IEventHandleFat(YdbProxy, Sender, ev));
             return Server.GetRuntime()->GrabEdgeEvent<TEvResponse>(Sender);
         }
 
diff --git a/ydb/core/tx/scheme_board/cache.cpp b/ydb/core/tx/scheme_board/cache.cpp
index 2360d09a3f8..b5b7a100325 100644
--- a/ydb/core/tx/scheme_board/cache.cpp
+++ b/ydb/core/tx/scheme_board/cache.cpp
@@ -96,7 +96,9 @@ namespace {
     template <typename TRequest, typename TEvRequest, typename TDerived>
     class TDbResolver: public TActorBootstrapped<TDerived> {
         void Handle() {
-            TlsActivationContext->Send(new IEventHandle(Cache, Sender, new TEvRequest(Request.Release())));
+            auto req = new TEvRequest(Request.Release());
+            req->PrepareSend(Cache, Sender);
+            TlsActivationContext->Send(req);
             this->PassAway();
         }
 
diff --git a/ydb/core/tx/scheme_board/cache_ut.cpp b/ydb/core/tx/scheme_board/cache_ut.cpp
index 3b92d1a922a..2f6b5602529 100644
--- a/ydb/core/tx/scheme_board/cache_ut.cpp
+++ b/ydb/core/tx/scheme_board/cache_ut.cpp
@@ -826,7 +826,7 @@ void TCacheTest::MigrationUndo() {
 
 void SimulateSleep(TTestContext& context, TDuration duration) {
     auto sender = context.AllocateEdgeActor();
-    context.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), duration);
+    context.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), duration);
     context.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
 }
 
diff --git a/ydb/core/tx/scheme_board/helpers.cpp b/ydb/core/tx/scheme_board/helpers.cpp
index add1b5a460d..422af265d0e 100644
--- a/ydb/core/tx/scheme_board/helpers.cpp
+++ b/ydb/core/tx/scheme_board/helpers.cpp
@@ -90,7 +90,7 @@ TIntrusivePtr<TEventSerializedData> SerializeEvent(IEventBase* ev) {
 void MultiSend(const TVector<const TActorId*>& recipients, const TActorId& sender, TAutoPtr<IEventBase> ev, ui32 flags, ui64 cookie) {
     auto buffer = SerializeEvent(ev.Get());
     for (const TActorId* recipient : recipients) {
-        TlsActivationContext->Send(new IEventHandle(
+        TlsActivationContext->Send(new IEventHandleFat(
             ev->Type(), flags, *recipient, sender, buffer, cookie
         ));
     }
diff --git a/ydb/core/tx/scheme_board/populator_ut.cpp b/ydb/core/tx/scheme_board/populator_ut.cpp
index c0eb1cb62fa..6cbb6973c47 100644
--- a/ydb/core/tx/scheme_board/populator_ut.cpp
+++ b/ydb/core/tx/scheme_board/populator_ut.cpp
@@ -96,7 +96,7 @@ public:
                 auto it = ReplicaPopulators.find(ev->Recipient);
                 if (DropFirstAcks && it != ReplicaPopulators.end() && !it->second) {
                     it->second = true;
-                    runtime.Send(new IEventHandle(ev->Recipient, ev->Sender, new TEvInterconnect::TEvNodeDisconnected(ev->Sender.NodeId())));
+                    runtime.Send(new IEventHandleFat(ev->Recipient, ev->Sender, new TEvInterconnect::TEvNodeDisconnected(ev->Sender.NodeId())));
 
                     return TTestContext::EEventAction::DROP;
                 }
diff --git a/ydb/core/tx/scheme_board/ut_helpers.h b/ydb/core/tx/scheme_board/ut_helpers.h
index 03de1fb2d5b..2bf69a2c826 100644
--- a/ydb/core/tx/scheme_board/ut_helpers.h
+++ b/ydb/core/tx/scheme_board/ut_helpers.h
@@ -36,7 +36,20 @@ public:
         ui32 senderNodeIndex = 0,
         bool viaActorSystem = false
     ) {
-        TTestBasicRuntime::Send(new IEventHandle(recipient, sender, ev, flags, cookie), senderNodeIndex, viaActorSystem);
+        TTestBasicRuntime::Send(new IEventHandleFat(recipient, sender, ev, flags, cookie), senderNodeIndex, viaActorSystem);
+    }
+
+    void Send(
+        const TActorId& recipient,
+        const TActorId& sender,
+        IEventHandleLight* ev,
+        ui32 flags = 0,
+        ui64 cookie = 0,
+        ui32 senderNodeIndex = 0,
+        bool viaActorSystem = false
+    ) {
+        ev->PrepareSend(recipient, sender, flags, cookie);
+        TTestBasicRuntime::Send(ev, senderNodeIndex, viaActorSystem);
     }
 
     void WaitForEvent(ui32 eventType) {
diff --git a/ydb/core/tx/scheme_cache/scheme_cache.h b/ydb/core/tx/scheme_cache/scheme_cache.h
index a7f76d4a113..2f85708c15a 100644
--- a/ydb/core/tx/scheme_cache/scheme_cache.h
+++ b/ydb/core/tx/scheme_cache/scheme_cache.h
@@ -448,7 +448,7 @@ struct TEvTxProxySchemeCache {
 
 private:
     template <typename TDerived, ui32 EventType, typename TRequest>
-    struct TEvBasic : public TEventLocal<TDerived, EventType> {
+    struct TEvBasic : public TEventLight<TDerived, EventType> {
         TAutoPtr<TRequest> Request;
 
         TEvBasic(TAutoPtr<TRequest> request)
diff --git a/ydb/core/tx/schemeshard/operation_queue_timer.h b/ydb/core/tx/schemeshard/operation_queue_timer.h
index 794c9368669..cfcafeb19ee 100644
--- a/ydb/core/tx/schemeshard/operation_queue_timer.h
+++ b/ydb/core/tx/schemeshard/operation_queue_timer.h
@@ -76,7 +76,7 @@ private:
         When = this->Now() + delta;
         auto ctx = TActivationContext::ActorContextFor(TActorBase::SelfId());
         LongTimerId = CreateLongTimer(ctx, delta,
-            new IEventHandle(TActorBase::SelfId(), TActorBase::SelfId(), new TEvWakeupQueue),
+            new IEventHandleFat(TActorBase::SelfId(), TActorBase::SelfId(), new TEvWakeupQueue),
             AppData(ctx)->UserPoolId);
 
         LOG_DEBUG_S(ctx, ServiceId,
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation.cpp b/ydb/core/tx/schemeshard/schemeshard__operation.cpp
index 345b0c965c0..5aeb859aea4 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation.cpp
@@ -493,7 +493,7 @@ struct TSchemeShard::TTxOperationPlanStep: public NTabletFlatExecutor::TTransact
 
                 TOperationContext context{Self, txc, ctx, OnComplete, MemChanges, DbChanges};
                 THolder<TEvPrivate::TEvOperationPlan> msg = MakeHolder<TEvPrivate::TEvOperationPlan>(ui64(step), ui64(txId));
-                TEvPrivate::TEvOperationPlan::TPtr personalEv = (TEventHandle<TEvPrivate::TEvOperationPlan>*) new IEventHandle(
+                TEvPrivate::TEvOperationPlan::TPtr personalEv = (TEventHandleFat<TEvPrivate::TEvOperationPlan>*) new IEventHandleFat(
                             context.SS->SelfId(), context.SS->SelfId(), msg.Release());
 
                 operation->Parts.at(partIdx)->HandleReply(personalEv, context);
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_side_effects.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_side_effects.cpp
index e0ab1cecde8..77b4dde0e18 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_side_effects.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_side_effects.cpp
@@ -974,7 +974,7 @@ void TSideEffects::DoCheckBarriers(TSchemeShard *ss, NTabletFlatExecutor::TTrans
         TOperationContext context{ss, txc, ctx, *this, memChanges, dbChanges};
 
         THolder<TEvPrivate::TEvCompleteBarrier> msg = MakeHolder<TEvPrivate::TEvCompleteBarrier>(txId, name);
-        TEvPrivate::TEvCompleteBarrier::TPtr personalEv = (TEventHandle<TEvPrivate::TEvCompleteBarrier>*) new IEventHandle(
+        TEvPrivate::TEvCompleteBarrier::TPtr personalEv = (TEventHandleFat<TEvPrivate::TEvCompleteBarrier>*) new IEventHandleFat(
                     context.SS->SelfId(), context.SS->SelfId(), msg.Release());
 
         for (auto& partId: blockedParts) {
diff --git a/ydb/core/tx/schemeshard/schemeshard__operation_upgrade_subdomain.cpp b/ydb/core/tx/schemeshard/schemeshard__operation_upgrade_subdomain.cpp
index 8057e55018c..f8593b670b8 100644
--- a/ydb/core/tx/schemeshard/schemeshard__operation_upgrade_subdomain.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__operation_upgrade_subdomain.cpp
@@ -1279,7 +1279,7 @@ public:
             Y_VERIFY(operation->Parts.size());
 
             THolder<TEvPrivate::TEvUndoTenantUpdate> msg = MakeHolder<TEvPrivate::TEvUndoTenantUpdate>();
-            TEvPrivate::TEvUndoTenantUpdate::TPtr personalEv = (TEventHandle<TEvPrivate::TEvUndoTenantUpdate>*) new IEventHandle(
+            TEvPrivate::TEvUndoTenantUpdate::TPtr personalEv = (TEventHandleFat<TEvPrivate::TEvUndoTenantUpdate>*) new IEventHandleFat(
                 context.SS->SelfId(), context.SS->SelfId(), msg.Release());
             operation->Parts.front()->HandleReply(personalEv, context);
         }
@@ -1423,14 +1423,14 @@ public:
         switch (decision) {
         case NKikimrSchemeOp::TUpgradeSubDomain::Commit: {
             THolder<TEvPrivate::TEvCommitTenantUpdate> msg = MakeHolder<TEvPrivate::TEvCommitTenantUpdate>();
-            TEvPrivate::TEvCommitTenantUpdate::TPtr personalEv = (TEventHandle<TEvPrivate::TEvCommitTenantUpdate>*) new IEventHandle(
+            TEvPrivate::TEvCommitTenantUpdate::TPtr personalEv = (TEventHandleFat<TEvPrivate::TEvCommitTenantUpdate>*) new IEventHandleFat(
                 context.SS->SelfId(), context.SS->SelfId(), msg.Release());
             operation->Parts.front()->HandleReply(personalEv, context);
             break;
         }
         case NKikimrSchemeOp::TUpgradeSubDomain::Undo: {
             THolder<TEvPrivate::TEvUndoTenantUpdate> msg = MakeHolder<TEvPrivate::TEvUndoTenantUpdate>();
-            TEvPrivate::TEvUndoTenantUpdate::TPtr personalEv = (TEventHandle<TEvPrivate::TEvUndoTenantUpdate>*) new IEventHandle(
+            TEvPrivate::TEvUndoTenantUpdate::TPtr personalEv = (TEventHandleFat<TEvPrivate::TEvUndoTenantUpdate>*) new IEventHandleFat(
                 context.SS->SelfId(), context.SS->SelfId(), msg.Release());
             operation->Parts.front()->HandleReply(personalEv, context);
             break;
diff --git a/ydb/core/tx/schemeshard/schemeshard__publish_to_scheme_board.cpp b/ydb/core/tx/schemeshard/schemeshard__publish_to_scheme_board.cpp
index 4824e22297b..26f4b8ab246 100644
--- a/ydb/core/tx/schemeshard/schemeshard__publish_to_scheme_board.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard__publish_to_scheme_board.cpp
@@ -128,7 +128,7 @@ struct TSchemeShard::TTxAckPublishToSchemeBoard: public TTransactionBase<TScheme
                                << ", txId: " << txId);
 
                 THolder<TEvPrivate::TEvCompletePublication> msg = MakeHolder<TEvPrivate::TEvCompletePublication>(opId, pathId, version);
-                TEvPrivate::TEvCompletePublication::TPtr personalEv = (TEventHandle<TEvPrivate::TEvCompletePublication>*) new IEventHandle(
+                TEvPrivate::TEvCompletePublication::TPtr personalEv = (TEventHandleFat<TEvPrivate::TEvCompletePublication>*) new IEventHandleFat(
                     Self->SelfId(), Self->SelfId(), msg.Release());
 
                 TMemoryChanges memChanges;
diff --git a/ydb/core/tx/schemeshard/schemeshard_export__create.cpp b/ydb/core/tx/schemeshard/schemeshard_export__create.cpp
index 486d3245cba..31ca8182f8f 100644
--- a/ydb/core/tx/schemeshard/schemeshard_export__create.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard_export__create.cpp
@@ -731,7 +731,7 @@ private:
                         }
 
                         ctx.TActivationContext::Schedule(TDuration::Seconds(10),
-                            new IEventHandle(Self->SelfId(), Self->SelfId(), ev.Release()));
+                            new IEventHandleFat(Self->SelfId(), Self->SelfId(), ev.Release()));
                         Self->TxIdToExport[txId] = {exportInfo->Id, itemIdx};
 
                         return;
diff --git a/ydb/core/tx/schemeshard/schemeshard_impl.cpp b/ydb/core/tx/schemeshard/schemeshard_impl.cpp
index 96cf92f744d..5aa4d5104a2 100644
--- a/ydb/core/tx/schemeshard/schemeshard_impl.cpp
+++ b/ydb/core/tx/schemeshard/schemeshard_impl.cpp
@@ -4153,7 +4153,7 @@ void TSchemeShard::Enqueue(STFUNC_SIG) {
     Y_UNUSED(ctx);
     Y_FAIL_S("No enqueue method implemented."
               << " unhandled event type: " << ev->GetTypeRewrite()
-             << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+             << " event: " << ev->ToString());
 
 }
 
@@ -4211,7 +4211,7 @@ void TSchemeShard::StateConfigure(STFUNC_SIG) {
             LOG_WARN_S(ctx, NKikimrServices::FLAT_TX_SCHEMESHARD,
                        "StateConfigure:"
                            << " unhandled event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
         }
     }
 }
@@ -4379,7 +4379,7 @@ void TSchemeShard::StateWork(STFUNC_SIG) {
             LOG_WARN_S(ctx, NKikimrServices::FLAT_TX_SCHEMESHARD,
                        "StateWork:"
                            << " unhandled event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
         }
         break;
     }
@@ -4394,7 +4394,7 @@ void TSchemeShard::BrokenState(STFUNC_SIG) {
             LOG_WARN_S(ctx, NKikimrServices::FLAT_TX_SCHEMESHARD,
                        "BrokenState:"
                            << " unhandled event type: " << ev->GetTypeRewrite()
-                           << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                           << " event: " << ev->ToString());
         }
         break;
     }
diff --git a/ydb/core/tx/schemeshard/schemeshard_xxport__tx_base.h b/ydb/core/tx/schemeshard/schemeshard_xxport__tx_base.h
index 84b46815c2c..cdfedda6b1c 100644
--- a/ydb/core/tx/schemeshard/schemeshard_xxport__tx_base.h
+++ b/ydb/core/tx/schemeshard/schemeshard_xxport__tx_base.h
@@ -20,7 +20,7 @@ protected:
     virtual ~TTxBase() = default;
 
     void Send(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0) {
-        SendOnComplete.emplace_back(new IEventHandle(recipient, Self->SelfId(), ev, flags, cookie));
+        SendOnComplete.emplace_back(new IEventHandleFat(recipient, Self->SelfId(), ev, flags, cookie));
     }
 
     template <typename TEvent>
diff --git a/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp b/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp
index f61c5a79e21..2ed931745fe 100644
--- a/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp
+++ b/ydb/core/tx/schemeshard/ut_helpers/helpers.cpp
@@ -43,7 +43,7 @@ namespace NSchemeShardUT_Private {
     {
         TActorId sender = runtime.AllocateEdgeActor();
         ui64 txId = evRequest->Record.GetTxId();
-        runtime.Send(new IEventHandle(proposer, sender, evRequest));
+        runtime.Send(new IEventHandleFat(proposer, sender, evRequest));
 
         auto evResponse = runtime.GrabEdgeEvent<TEvResponse>(sender);
         UNIT_ASSERT(evResponse);
@@ -343,7 +343,7 @@ namespace NSchemeShardUT_Private {
         entry.RequestType = TNavigate::TEntry::ERequestType::ByPath;
         entry.Operation = op;
         entry.ShowPrivatePath = true;
-        runtime.Send(new IEventHandle(MakeSchemeCacheID(), sender, new TEvRequest(request.Release())));
+        runtime.Send(MakeSchemeCacheID(), sender, new TEvRequest(request.Release()));
 
         auto ev = runtime.GrabEdgeEventRethrow<TEvResponse>(sender);
         UNIT_ASSERT(ev);
@@ -1624,7 +1624,7 @@ namespace NSchemeShardUT_Private {
                 tx->AddTables()->SetTablePath(path);
             }
             tx->SetTimeoutMs(timeout.MilliSeconds());
-            runtime.Send(new IEventHandle(MakeTxProxyID(), sender, request.Release()));
+            runtime.Send(new IEventHandleFat(MakeTxProxyID(), sender, request.Release()));
         }
 
         auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(sender);
diff --git a/ydb/core/tx/schemeshard/ut_helpers/test_env.cpp b/ydb/core/tx/schemeshard/ut_helpers/test_env.cpp
index d6cec4e1edb..f7f3e0d5d92 100644
--- a/ydb/core/tx/schemeshard/ut_helpers/test_env.cpp
+++ b/ydb/core/tx/schemeshard/ut_helpers/test_env.cpp
@@ -328,7 +328,7 @@ private:
         LOG_DEBUG_S(ctx, NKikimrServices::FLAT_TX_SCHEMESHARD,
                     "TFakeMetering:"
                         << " unhandled event type: " << ev->GetTypeRewrite()
-                        << " event: " << (ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?"));
+                        << " event: " << ev->ToString());
     }
 
 private:
@@ -708,7 +708,7 @@ void NSchemeShardUT_Private::TestWaitNotification(NActors::TTestActorRuntime &ru
     for (ui64 txId : txIds) {
         Cerr << Endl << "TestWaitNotification wait txId: " << txId << Endl;
         auto ev = new TEvSchemeShard::TEvNotifyTxCompletion(txId);
-        runtime.Send(new IEventHandle(subscriberActorId, sender, ev));
+        runtime.Send(new IEventHandleFat(subscriberActorId, sender, ev));
     }
 
     TAutoPtr<IEventHandle> handle;
@@ -797,7 +797,7 @@ void NSchemeShardUT_Private::TTestEnv::TestWaitShardDeletion(NActors::TTestActor
 
 void NSchemeShardUT_Private::TTestEnv::SimulateSleep(NActors::TTestActorRuntime &runtime, TDuration duration) {
     auto sender = runtime.AllocateEdgeActor();
-    runtime.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), duration);
+    runtime.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), duration);
     runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
 }
 
diff --git a/ydb/core/tx/sequenceproxy/sequenceproxy_ut.cpp b/ydb/core/tx/sequenceproxy/sequenceproxy_ut.cpp
index d331fdef4ae..20ab9c04085 100644
--- a/ydb/core/tx/sequenceproxy/sequenceproxy_ut.cpp
+++ b/ydb/core/tx/sequenceproxy/sequenceproxy_ut.cpp
@@ -75,7 +75,7 @@ Y_UNIT_TEST_SUITE(SequenceProxy) {
 #if 0
         void SimulateSleep(TTestActorRuntime& runtime, TDuration duration) {
             auto sender = runtime.AllocateEdgeActor();
-            runtime.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), duration);
+            runtime.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), duration);
             runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
         }
 #endif
@@ -89,7 +89,7 @@ Y_UNIT_TEST_SUITE(SequenceProxy) {
             auto* op = tx->MutableSequence();
             bool parseResult = ::google::protobuf::TextFormat::ParseFromString(scheme, op);
             UNIT_ASSERT_C(parseResult, "protobuf parsing failed");
-            runtime.Send(new IEventHandle(MakeTxProxyID(), edge, request.Release()));
+            runtime.Send(new IEventHandleFat(MakeTxProxyID(), edge, request.Release()));
 
             auto ev = runtime.GrabEdgeEventRethrow<TEvTxUserProxy::TEvProposeTransactionStatus>(edge);
             auto* msg = ev->Get();
@@ -105,7 +105,7 @@ Y_UNIT_TEST_SUITE(SequenceProxy) {
 
         void SendNextValRequest(TTestActorRuntime& runtime, const TActorId& sender, const TString& path) {
             auto request = MakeHolder<TEvSequenceProxy::TEvNextVal>(path);
-            runtime.Send(new IEventHandle(MakeSequenceProxyServiceID(), sender, request.Release()));
+            runtime.Send(new IEventHandleFat(MakeSequenceProxyServiceID(), sender, request.Release()));
         }
 
         i64 WaitNextValResult(TTestActorRuntime& runtime, const TActorId& sender, Ydb::StatusIds::StatusCode expectedStatus = Ydb::StatusIds::SUCCESS) {
diff --git a/ydb/core/tx/tiering/ut/ut_tiers.cpp b/ydb/core/tx/tiering/ut/ut_tiers.cpp
index b6e8e77242c..e71c4ffb04c 100644
--- a/ydb/core/tx/tiering/ut/ut_tiers.cpp
+++ b/ydb/core/tx/tiering/ut/ut_tiers.cpp
@@ -150,9 +150,9 @@ Y_UNIT_TEST_SUITE(ColumnShardTiers) {
         void CheckRuntime(TTestActorRuntime& runtime) {
             const auto pred = [this](TTestActorRuntimeBase&, TAutoPtr<IEventHandle>& event)->TTestActorRuntimeBase::EEventAction {
                 if (event->HasBuffer() && !event->HasEvent()) {
-                } else if (!event->GetBase()) {
+                } else if (!event->HasEvent()) {
                 } else {
-                    auto ptr = dynamic_cast<NMetadata::NProvider::TEvRefreshSubscriberData*>(event->GetBase());
+                    auto ptr = event->CastAsLocal<NMetadata::NProvider::TEvRefreshSubscriberData>();
                     if (ptr) {
                         CheckFound(ptr);
                     }
diff --git a/ydb/core/tx/time_cast/time_cast_ut.cpp b/ydb/core/tx/time_cast/time_cast_ut.cpp
index 0acb2ee1289..07534fd0e40 100644
--- a/ydb/core/tx/time_cast/time_cast_ut.cpp
+++ b/ydb/core/tx/time_cast/time_cast_ut.cpp
@@ -11,13 +11,13 @@ namespace NKikimr::NMediatorTimeCastTest {
 
         void SimulateSleep(TTestActorRuntime& runtime, TDuration duration) {
             auto sender = runtime.AllocateEdgeActor();
-            runtime.Schedule(new IEventHandle(sender, sender, new TEvents::TEvWakeup()), duration);
+            runtime.Schedule(new IEventHandleFat(sender, sender, new TEvents::TEvWakeup()), duration);
             runtime.GrabEdgeEventRethrow<TEvents::TEvWakeup>(sender);
         }
 
         void SendSubscribeRequest(TTestActorRuntime& runtime, const TActorId& sender, ui64 coordinatorId, ui64 cookie = 0) {
             auto request = MakeHolder<TEvMediatorTimecast::TEvSubscribeReadStep>(coordinatorId);
-            runtime.Send(new IEventHandle(MakeMediatorTimecastProxyID(), sender, request.Release(), 0, cookie), 0, true);
+            runtime.Send(new IEventHandleFat(MakeMediatorTimecastProxyID(), sender, request.Release(), 0, cookie), 0, true);
         }
 
         TEvMediatorTimecast::TEvSubscribeReadStepResult::TPtr WaitSubscribeResult(TTestActorRuntime& runtime, const TActorId& sender) {
@@ -26,7 +26,7 @@ namespace NKikimr::NMediatorTimeCastTest {
 
         void SendWaitRequest(TTestActorRuntime& runtime, const TActorId& sender, ui64 coordinatorId, ui64 readStep, ui64 cookie = 0) {
             auto request = MakeHolder<TEvMediatorTimecast::TEvWaitReadStep>(coordinatorId, readStep);
-            runtime.Send(new IEventHandle(MakeMediatorTimecastProxyID(), sender, request.Release(), 0, cookie), 0, true);
+            runtime.Send(new IEventHandleFat(MakeMediatorTimecastProxyID(), sender, request.Release(), 0, cookie), 0, true);
         }
 
         TEvMediatorTimecast::TEvNotifyReadStep::TPtr WaitNotifyResult(TTestActorRuntime& runtime, const TActorId& sender) {
diff --git a/ydb/core/tx/tx_allocator_client/ut_helpers.cpp b/ydb/core/tx/tx_allocator_client/ut_helpers.cpp
index ec2ddcce263..07eacb5263b 100644
--- a/ydb/core/tx/tx_allocator_client/ut_helpers.cpp
+++ b/ydb/core/tx/tx_allocator_client/ut_helpers.cpp
@@ -38,7 +38,7 @@ void TTestEnv::AsyncAllocate(ui64 size) {
     Y_VERIFY(TxAllocatorClient);
     TActorId sender = Runtime.AllocateEdgeActor();
     TEvTxAllocatorClient::TEvAllocate *ev = new TEvTxAllocatorClient::TEvAllocate(size);
-    Runtime.Send(new IEventHandle(TxAllocatorClient, sender, ev, 0, SomeCockie(size)), 0, true);
+    Runtime.Send(new IEventHandleFat(TxAllocatorClient, sender, ev, 0, SomeCockie(size)), 0, true);
 }
 
 void TTestEnv::Boot() {
diff --git a/ydb/core/tx/tx_proxy/commitreq.cpp b/ydb/core/tx/tx_proxy/commitreq.cpp
index 3a7982a8db7..8d8e2cee3b6 100644
--- a/ydb/core/tx/tx_proxy/commitreq.cpp
+++ b/ydb/core/tx/tx_proxy/commitreq.cpp
@@ -108,7 +108,7 @@ public:
 
         // Schedule execution timeout
         {
-            THolder<IEventHandle> wakeupEv = MakeHolder<IEventHandle>(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup());
+            THolder<IEventHandle> wakeupEv = MakeHolder<IEventHandleFat>(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup());
             ExecTimeoutCookieHolder.Reset(ISchedulerCookie::Make2Way());
 
             CreateLongTimer(ctx, ExecTimeoutPeriod, wakeupEv, AppData(ctx)->SystemPoolId, ExecTimeoutCookieHolder.Get());
diff --git a/ydb/core/tx/tx_proxy/datareq.cpp b/ydb/core/tx/tx_proxy/datareq.cpp
index 90444545da3..23684d0463b 100644
--- a/ydb/core/tx/tx_proxy/datareq.cpp
+++ b/ydb/core/tx/tx_proxy/datareq.cpp
@@ -1308,7 +1308,7 @@ void TDataReq::Handle(TEvTxProxyReq::TEvMakeRequest::TPtr &ev, const TActorConte
 
     // Schedule execution timeout
     {
-        TAutoPtr<IEventHandle> wakeupEv(new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
+        TAutoPtr<IEventHandle> wakeupEv(new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
         ExecTimeoutCookieHolder.Reset(ISchedulerCookie::Make2Way());
 
         CreateLongTimer(ctx, ExecTimeoutPeriod, wakeupEv, AppData(ctx)->SystemPoolId, ExecTimeoutCookieHolder.Get());
diff --git a/ydb/core/tx/tx_proxy/read_table_impl.cpp b/ydb/core/tx/tx_proxy/read_table_impl.cpp
index f05e344c7bb..8397120b3fb 100644
--- a/ydb/core/tx/tx_proxy/read_table_impl.cpp
+++ b/ydb/core/tx/tx_proxy/read_table_impl.cpp
@@ -1325,7 +1325,7 @@ private:
                 state.RefreshTimer = CreateLongTimer(
                     ctx,
                     SNAPSHOT_TIMEOUT / 2,
-                    new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRefreshShard(shardId, ++state.RefreshSeqNo)));
+                    new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRefreshShard(shardId, ++state.RefreshSeqNo)));
 
                 if (state.ShardPosition == ShardList.end()) {
                     // We don't want to read from this shard at this time
@@ -1600,7 +1600,7 @@ private:
                 TXLOG_T("Ignore propose result from ShardId# " << shardId << " TxId# " << msg->GetTxId()
                         << " in State# " << state.State << " ReadTxId# " << state.ReadTxId);
                 // Pretend we don't exist if sender tracks delivery
-                ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+                ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
                 return;
         }
 
@@ -1992,7 +1992,7 @@ private:
         if (state.State != EShardState::ReadTableStreaming || state.ReadTxId != record.GetTxId()) {
             // Ignore outdated messages and pretend we don't exist
             TXLOG_T("Ignoring outdated TEvStreamQuotaRequest from ShardId# " << shardId);
-            ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+            ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
             return;
         }
 
@@ -2041,7 +2041,7 @@ private:
         if (state.State != EShardState::ReadTableStreaming || state.ReadTxId != record.GetTxId()) {
             // Ignore outdated messages and pretend we don't exist
             TXLOG_T("Ignoring outdated TEvStreamQuotaRelease from ShardId# " << shardId);
-            ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+            ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
             return;
         }
 
@@ -2260,7 +2260,7 @@ private:
         state.RetryTimer = CreateLongTimer(
                 ctx,
                 delay,
-                new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRetryShard(shardId, state.RetrySeqNo)));
+                new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRetryShard(shardId, state.RetrySeqNo)));
         return true;
     }
 
@@ -2309,7 +2309,7 @@ private:
         state.RefreshTimer = CreateLongTimer(
             ctx,
             SNAPSHOT_TIMEOUT / 2,
-            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRefreshShard(state.ShardId, ++state.RefreshSeqNo)));
+            new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRefreshShard(state.ShardId, ++state.RefreshSeqNo)));
     }
 
     void ScheduleRefreshShardRetry(TShardState& state, const TActorContext& ctx) {
@@ -2317,7 +2317,7 @@ private:
         state.RefreshTimer = CreateLongTimer(
             ctx,
             state.SelectNextRefreshDelay(),
-            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRefreshShard(state.ShardId, ++state.RefreshSeqNo)));
+            new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvPrivate::TEvRefreshShard(state.ShardId, ++state.RefreshSeqNo)));
     }
 
     void HandleRefreshShard(TEvPrivate::TEvRefreshShard::TPtr& ev, const TActorContext&) {
@@ -2705,7 +2705,7 @@ private:
             HFunc(TEvTxProxySchemeCache::TEvResolveKeySetResult, HandleZombieDie);
             default:
                 // For all other events we play dead as if we didn't exist
-                ctx.Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+                ctx.Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
                 break;
         }
     }
diff --git a/ydb/core/tx/tx_proxy/snapshotreq.cpp b/ydb/core/tx/tx_proxy/snapshotreq.cpp
index 727888fd74f..0a5d5d21d4c 100644
--- a/ydb/core/tx/tx_proxy/snapshotreq.cpp
+++ b/ydb/core/tx/tx_proxy/snapshotreq.cpp
@@ -157,7 +157,7 @@ public:
 
         // Schedule execution timeout
         {
-            THolder<IEventHandle> wakeupEv = MakeHolder<IEventHandle>(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup());
+            THolder<IEventHandle> wakeupEv = MakeHolder<IEventHandleFat>(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup());
             ExecTimeoutCookieHolder.Reset(ISchedulerCookie::Make2Way());
 
             CreateLongTimer(ctx, ExecTimeoutPeriod, wakeupEv, AppData(ctx)->SystemPoolId, ExecTimeoutCookieHolder.Get());
@@ -1190,7 +1190,7 @@ public:
 
         // Schedule execution timeout
         {
-            THolder<IEventHandle> wakeupEv = MakeHolder<IEventHandle>(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup());
+            THolder<IEventHandle> wakeupEv = MakeHolder<IEventHandleFat>(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup());
             ExecTimeoutCookieHolder.Reset(ISchedulerCookie::Make2Way());
 
             CreateLongTimer(ctx, ExecTimeoutPeriod, wakeupEv, AppData(ctx)->SystemPoolId, ExecTimeoutCookieHolder.Get());
diff --git a/ydb/core/tx/tx_proxy/storage_tenant_ut.cpp b/ydb/core/tx/tx_proxy/storage_tenant_ut.cpp
index c3b8e9921a8..b895d33e7c0 100644
--- a/ydb/core/tx/tx_proxy/storage_tenant_ut.cpp
+++ b/ydb/core/tx/tx_proxy/storage_tenant_ut.cpp
@@ -363,7 +363,7 @@ Y_UNIT_TEST_SUITE(TStorageTenantTest) {
                     TInstant::Max());                 // deadline
 
         TActorId nodeWarden = MakeBlobStorageNodeWardenID(runtime->GetNodeId(nodeIdx));
-        runtime->Send(new IEventHandle(MakeBlobStorageProxyID(group), edge, event.Release(),
+        runtime->Send(new IEventHandleFat(MakeBlobStorageProxyID(group), edge, event.Release(),
                                        IEventHandle::FlagForwardOnNondelivery, 0, &nodeWarden), nodeIdx);
 
         TEvBlobStorage::TEvCollectGarbageResult::TPtr response = runtime->GrabEdgeEventRethrow<TEvBlobStorage::TEvCollectGarbageResult>(edge);
diff --git a/ydb/core/tx/tx_proxy/upload_rows_common_impl.h b/ydb/core/tx/tx_proxy/upload_rows_common_impl.h
index a9acdd64e2e..988cd9fff27 100644
--- a/ydb/core/tx/tx_proxy/upload_rows_common_impl.h
+++ b/ydb/core/tx/tx_proxy/upload_rows_common_impl.h
@@ -484,7 +484,7 @@ private:
         ctx.Send(SchemeCache, new TEvTxProxySchemeCache::TEvNavigateKeySet(request));
 
         TimeoutTimerActorId = CreateLongTimer(ctx, Timeout,
-            new IEventHandle(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
+            new IEventHandleFat(ctx.SelfID, ctx.SelfID, new TEvents::TEvWakeup()));
 
         TBase::Become(&TThis::StateWaitResolveTable);
         WaitingResolveReply = true;
diff --git a/ydb/core/util/single_thread_ic_mock.cpp b/ydb/core/util/single_thread_ic_mock.cpp
index ec5542adc72..dcb6a02ecec 100644
--- a/ydb/core/util/single_thread_ic_mock.cpp
+++ b/ydb/core/util/single_thread_ic_mock.cpp
@@ -152,20 +152,20 @@ public:
         // notify all subscribers
         for (const auto& [actorId, cookie] : Subscribers) {
             auto ev = std::make_unique<TEvInterconnect::TEvNodeDisconnected>(Proxy->PeerNodeId);
-            Proxy->Mock->TestActorSystem->Send(new IEventHandle(actorId, SelfId(), ev.release(), 0, cookie),
+            Proxy->Mock->TestActorSystem->Send(new IEventHandleFat(actorId, SelfId(), ev.release(), 0, cookie),
                 Proxy->Node->NodeId);
         }
 
         // drop unsent messages
         for (auto& [_, queue] : Outbox) {
             for (auto& ev : queue) {
-                Proxy->Mock->TestActorSystem->Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected).Release(),
+                Proxy->Mock->TestActorSystem->Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected).Release(),
                     Proxy->Node->NodeId);
             }
         }
 
         // transit to self-destruction state
-        Proxy->Mock->TestActorSystem->Send(new IEventHandle(TEvents::TSystem::Poison, 0, SelfId(), {}, nullptr, 0),
+        Proxy->Mock->TestActorSystem->Send(new IEventHandleFat(TEvents::TSystem::Poison, 0, SelfId(), {}, nullptr, 0),
             Proxy->Node->NodeId);
         Become(&TThis::StateUndelivered); // do not handle further events
 
@@ -178,7 +178,7 @@ public:
         if (ev->GetTypeRewrite() == TEvents::TSystem::Poison) {
             TActor::PassAway();
         } else {
-            TActivationContext::Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
+            TActivationContext::Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown));
         }
     }
 
@@ -215,7 +215,10 @@ public:
             const TInstant now = TActivationContext::Now();
             Y_VERIFY(now == NextSendTimestamp);
             Y_VERIFY(Proxy->Peer && Proxy->Peer->SessionActor);
-            const_cast<TScopeId&>(ev->OriginScopeId) = Proxy->Common->LocalScopeId;
+            if (ev->IsEventFat()) {
+                auto* evf = IEventHandleFat::GetFat(ev);
+                const_cast<TScopeId&>(evf->OriginScopeId) = Proxy->Common->LocalScopeId;
+            }
             Proxy->Peer->SessionActor->PutToInbox(ev);
 
             if (Outbox.empty()) {
@@ -230,7 +233,7 @@ public:
                 if (q.empty()) {
                     Outbox.erase(it);
                 }
-                
+
                 ScheduleSendEvent(ev);
             }
         }
@@ -262,25 +265,33 @@ public:
             const TInstant now = TActivationContext::Now();
             Y_VERIFY(now == NextReceiveTimestamp);
 
-            auto fw = std::make_unique<IEventHandle>(
-                SelfId(),
-                ev->Type,
-                ev->Flags & ~IEventHandle::FlagForwardOnNondelivery,
-                ev->Recipient,
-                ev->Sender,
-                ev->ReleaseChainBuffer(),
-                ev->Cookie,
-                ev->OriginScopeId,
-                std::move(ev->TraceId)
-            );
+            std::unique_ptr<IEventHandle> fw;
+            if (ev->IsEventFat()) {
+                auto* evf = IEventHandleFat::GetFat(ev);
+                fw = std::make_unique<IEventHandleFat>(
+                    SelfId(),
+                    evf->Type,
+                    evf->Flags & ~IEventHandle::FlagForwardOnNondelivery,
+                    evf->Recipient,
+                    evf->Sender,
+                    evf->ReleaseChainBuffer(),
+                    evf->Cookie,
+                    evf->OriginScopeId,
+                    std::move(evf->TraceId)
+                );
+            } else {
+                fw.reset(ev.Release());
+            }
 
             STLOG(PRI_TRACE, INTERCONNECT_SESSION, STIM04, Prefix << "HandleReceive", (SelfId, SelfId()),
                 (Type, fw->Type), (Sender, fw->Sender), (Recipient, fw->Recipient), (Flags, fw->Flags),
                 (Cookie, ev->Cookie));
 
-            auto& common = Proxy->Common;
-            if (!common->EventFilter || common->EventFilter->CheckIncomingEvent(*fw, common->LocalScopeId)) {
-                Proxy->Mock->TestActorSystem->Send(fw.release(), Proxy->Node->NodeId);
+            if (fw->IsEventFat()) {
+                auto& common = Proxy->Common;
+                if (!common->EventFilter || common->EventFilter->CheckIncomingEvent(*IEventHandleFat::GetFat(fw), common->LocalScopeId)) {
+                    Proxy->Mock->TestActorSystem->Send(fw.release(), Proxy->Node->NodeId);
+                }
             }
 
             if (Inbox.empty()) {
@@ -360,12 +371,12 @@ void TMock::TProxyActor::CreateSession() {
 
 void TMock::TProxyActor::ForwardToSession(TAutoPtr<IEventHandle> ev) {
     if (TSessionActor *session = GetSession()) {
-        InvokeOtherActor(*session, &TSessionActor::Receive, ev, TActivationContext::ActorContextFor(session->SelfId()));
+        InvokeOtherActor(*session, &TSessionActor::Receive, ev);
     } else {
         const bool first = PendingEvents.empty();
         PendingEvents.emplace_back(ev.Release());
         if (first) {
-            TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandle(EvDropPendingEvents, 0, SelfId(), {},
+            TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandleFat(EvDropPendingEvents, 0, SelfId(), {},
                 nullptr, ++DropPendingEventsCookie));
         }
     }
@@ -377,7 +388,7 @@ void TMock::TProxyActor::DropSessionEvent(std::unique_ptr<IEventHandle> ev) {
             if (ev->Flags & IEventHandle::FlagSubscribeOnSession) {
                 Send(ev->Sender, new TEvInterconnect::TEvNodeDisconnected(PeerNodeId), 0, ev->Cookie);
             }
-            TActivationContext::Send(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::Disconnected));
+            TActivationContext::Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::Disconnected));
             break;
 
         case TEvInterconnect::EvConnectNode:
@@ -437,7 +448,7 @@ std::unique_ptr<IActor> TMock::CreateProxyActor(ui32 nodeId, ui32 peerNodeId,
 
     auto& ptr = Proxies[{nodeId, peerNodeId}];
     Y_VERIFY(!ptr); // no multiple proxies for the same direction are allowed
-    
+
     auto& node = Nodes[nodeId];
     if (!node) {
         node = std::make_shared<TNode>(nodeId, BurstCapacityBytes, BytesPerSecond);
diff --git a/ydb/core/util/testactorsys.cpp b/ydb/core/util/testactorsys.cpp
index 6dd2760001d..dc6c1fe8dea 100644
--- a/ydb/core/util/testactorsys.cpp
+++ b/ydb/core/util/testactorsys.cpp
@@ -118,7 +118,7 @@ void TTestActorSystem::SendToPipe(ui64 tabletId, const TActorId& sender, IEventB
     WrapInActorContext(sender, [&] { // perform action in sender's context
         const TActorId clientId = Register(NKikimr::NTabletPipe::CreateClient(sender, tabletId, pipeConfig));
         NTabletPipe::SendData(sender, clientId, payload, cookie);
-        Send(new IEventHandle(clientId, sender, new NKikimr::TEvTabletPipe::TEvShutdown()));
+        Send(new IEventHandleFat(clientId, sender, new NKikimr::TEvTabletPipe::TEvShutdown()));
     });
 }
 
diff --git a/ydb/core/util/testactorsys.h b/ydb/core/util/testactorsys.h
index af46b14ab6f..729967f642a 100644
--- a/ydb/core/util/testactorsys.h
+++ b/ydb/core/util/testactorsys.h
@@ -364,12 +364,7 @@ public:
         Y_VERIFY(!res, "failed to set log level: %s", explanation.data());
     }
 
-    bool Send(IEventHandle *ev, ui32 nodeId = 0) {
-        TAutoPtr<IEventHandle> wrapper(ev);
-        return Send(wrapper, nodeId);
-    }
-
-    bool Send(TAutoPtr<IEventHandle>& ev, ui32 nodeId) {
+    bool Send(TAutoPtr<IEventHandle> ev, ui32 nodeId = 0) {
         if (!ev) {
             return false;
         } else if (LoggerActorIds.count(ev->GetRecipientRewrite()) && ev->GetTypeRewrite() == NLog::TEvLog::EventType) {
@@ -398,8 +393,7 @@ public:
             Schedule(Clock, ev, nullptr, nodeId);
             return true;
         } else {
-            TAutoPtr<IEventHandle> wrapper(ev->ForwardOnNondelivery(TEvents::TEvUndelivered::ReasonActorUnknown));
-            Send(wrapper, nodeId);
+            Send(IEventHandle::ForwardOnNondelivery(ev, TEvents::TEvUndelivered::ReasonActorUnknown), nodeId);
             return false;
         }
     }
@@ -420,8 +414,17 @@ public:
         Y_VERIFY(ts >= Clock);
         nodeId = nodeId ? nodeId : CurrentNodeId;
         Y_VERIFY(nodeId);
-        if (ev && ev->HasEvent() && ev->GetTypeRewrite() == ev->Type && !EventName.count(ev->Type)) {
-            EventName.emplace(ev->Type, TypeName(*ev->GetBase()));
+        if (ev) {
+            if (ev->IsEventLight()) {
+                if (ev->GetTypeRewrite() == ev->Type && !EventName.count(ev->Type)) {
+                    EventName.emplace(ev->Type, TypeName(*ev));
+                }
+            } else {
+                auto* evf = IEventHandleFat::GetFat(ev.Get());
+                if (evf && evf->HasEvent() && evf->GetTypeRewrite() == evf->Type && !EventName.count(evf->Type)) {
+                    EventName.emplace(evf->Type, TypeName(*evf->GetBase()));
+                }
+            }
         }
         std::unique_ptr<IEventHandle> evPtr(ev.Release());
         if (!FilterEnqueue || FilterEnqueue(nodeId, evPtr, cookie, ts)) {
@@ -524,7 +527,7 @@ public:
                 const ui32 type = ev->GetTypeRewrite();
 
                 THPTimer timer;
-                actor->Receive(ev, TActivationContext::AsActorContext());
+                actor->Receive(ev);
                 const TDuration timing = TDuration::Seconds(timer.Passed());
 
                 const auto it = ActorName.find(actor);
@@ -619,13 +622,13 @@ public:
     }
 
     template<typename TEvent>
-    std::unique_ptr<TEventHandle<TEvent>> WaitForEdgeActorEvent(const TActorId& edgeActorId, bool termOnCapture = true) {
+    std::unique_ptr<TEventHandleFat<TEvent>> WaitForEdgeActorEvent(const TActorId& edgeActorId, bool termOnCapture = true) {
         auto ev = WaitForEdgeActorEvent({edgeActorId});
         Y_VERIFY(ev->GetTypeRewrite() == TEvent::EventType, "unexpected Event# 0x%08" PRIx32, ev->GetTypeRewrite());
         if (termOnCapture) {
             DestroyActor(edgeActorId);
         }
-        return std::unique_ptr<TEventHandle<TEvent>>(reinterpret_cast<TEventHandle<TEvent>*>(ev.release()));
+        return std::unique_ptr<TEventHandleFat<TEvent>>(reinterpret_cast<TEventHandleFat<TEvent>*>(ev.release()));
     }
 
     void DestroyActor(TActorId actorId) {
@@ -717,7 +720,7 @@ private:
         Y_VERIFY(nodeId);
         TActorId recip = ev->GetRecipientRewrite();
         if (recip.NodeId() && recip.NodeId() != nodeId) {
-            Y_VERIFY(!ev->HasEvent() || ev->GetBase()->IsSerializable(), "event can't pass through interconnect");
+            //Y_VERIFY(!ev->HasEvent() || ev->GetBase()->IsSerializable(), "event can't pass through interconnect");
             Y_VERIFY(ev->Recipient == recip, "original recipient actor id lost");
             recip = GetNode(nodeId)->ActorSystem->InterconnectProxy(recip.NodeId());
             ev->Rewrite(TEvInterconnect::EvForward, recip);
diff --git a/ydb/core/viewer/json_netinfo.h b/ydb/core/viewer/json_netinfo.h
index 8d4ab1ddee1..0a13cb4f449 100644
--- a/ydb/core/viewer/json_netinfo.h
+++ b/ydb/core/viewer/json_netinfo.h
@@ -155,7 +155,7 @@ public:
     void Handle(TEvTxProxySchemeCache::TEvNavigateKeySetResult::TPtr& ev) {
         if (ev->Get()->Request->ResultSet.size() == 1 && ev->Get()->Request->ResultSet.begin()->Status == NSchemeCache::TSchemeCacheNavigate::EStatus::Ok) {
             TString path = CanonizePath(ev->Get()->Request->ResultSet.begin()->Path);
-            NavigateResult[path].reset(ev->Release().Release());
+            NavigateResult[path].reset(ev.Release());
         }
         RequestDone();
     }
diff --git a/ydb/core/viewer/json_pipe_req.h b/ydb/core/viewer/json_pipe_req.h
index 197ceabd79f..fbbe2e01603 100644
--- a/ydb/core/viewer/json_pipe_req.h
+++ b/ydb/core/viewer/json_pipe_req.h
@@ -71,11 +71,16 @@ protected:
     }
 
     void SendRequest(const TActorId& recipient, IEventBase* ev, ui32 flags = 0, ui64 cookie = 0) {
-        SendEvent(std::make_unique<IEventHandle>(recipient, TBase::SelfId(), ev, flags, cookie));
+        SendEvent(std::make_unique<IEventHandleFat>(recipient, TBase::SelfId(), ev, flags, cookie));
+    }
+
+    void SendRequest(const TActorId& recipient, IEventHandleLight* ev, ui32 flags = 0, ui64 cookie = 0) {
+        ev->PrepareSend(recipient, TBase::SelfId(), flags, cookie);
+        SendEvent(std::unique_ptr<IEventHandle>(ev));
     }
 
     void SendRequestToPipe(const TActorId& pipe, IEventBase* ev, ui64 cookie = 0) {
-        std::unique_ptr<IEventHandle> event = std::make_unique<IEventHandle>(pipe, TBase::SelfId(), ev, 0/*flags*/, cookie);
+        std::unique_ptr<IEventHandle> event = std::make_unique<IEventHandleFat>(pipe, TBase::SelfId(), ev, 0/*flags*/, cookie);
         event->Rewrite(TEvTabletPipe::EvSend, pipe);
         SendEvent(std::move(event));
     }
diff --git a/ydb/core/wrappers/s3_wrapper_ut.cpp b/ydb/core/wrappers/s3_wrapper_ut.cpp
index b864e183010..15eced6c620 100644
--- a/ydb/core/wrappers/s3_wrapper_ut.cpp
+++ b/ydb/core/wrappers/s3_wrapper_ut.cpp
@@ -63,7 +63,7 @@ public:
             Edge = Runtime->AllocateEdgeActor();
         }
 
-        Runtime->Send(new IEventHandle(Wrapper, *Edge, ev));
+        Runtime->Send(new IEventHandleFat(Wrapper, *Edge, ev));
         return Runtime->GrabEdgeEvent<TEvResponse>(*Edge);
     }
 
diff --git a/ydb/core/ymq/actor/common_batch_actor.h b/ydb/core/ymq/actor/common_batch_actor.h
index 1d9cc6916d9..7f6e51fb635 100644
--- a/ydb/core/ymq/actor/common_batch_actor.h
+++ b/ydb/core/ymq/actor/common_batch_actor.h
@@ -18,7 +18,7 @@ public:
 private:
     void DoSendReply(const NKikimrClient::TSqsResponse& resp) override {
         const TActorId sender = TActivationContext::AsActorContext().SelfID;
-        TActivationContext::Send(new IEventHandle(BatchActor_, sender, new TSqsEvents::TEvSqsResponse(resp), 0, Cookie_));
+        TActivationContext::Send(new IEventHandleFat(BatchActor_, sender, new TSqsEvents::TEvSqsResponse(resp), 0, Cookie_));
     }
 
 private:
diff --git a/ydb/core/ymq/actor/executor.cpp b/ydb/core/ymq/actor/executor.cpp
index c6413f25a43..6f13cf27d8a 100644
--- a/ydb/core/ymq/actor/executor.cpp
+++ b/ydb/core/ymq/actor/executor.cpp
@@ -112,7 +112,7 @@ void TExecutorBuilder::SendToQueueLeader() {
 
     RLOG_SQS_DEBUG("Sending execute request for query(idx=" << QueryId_ << ") to queue leader");
 
-    TActivationContext::Send(new IEventHandle(QueueLeaderActor_, Parent_, ev.Release()));
+    TActivationContext::Send(new IEventHandleFat(QueueLeaderActor_, Parent_, ev.Release()));
 }
 
 TMiniKqlExecutionActor::TMiniKqlExecutionActor(
diff --git a/ydb/core/ymq/actor/node_tracker.cpp b/ydb/core/ymq/actor/node_tracker.cpp
index eab06da69ae..1fdc020347e 100644
--- a/ydb/core/ymq/actor/node_tracker.cpp
+++ b/ydb/core/ymq/actor/node_tracker.cpp
@@ -84,13 +84,11 @@ namespace NKikimr::NSQS {
         navigateRequest->ResultSet.resize(2);

         navigateRequest->ResultSet.front().Path = TablePathSTD;

         navigateRequest->ResultSet.back().Path = TablePathFIFO;

+        auto ev = MakeHolder<TEvTxProxySchemeCache::TEvNavigateKeySet>(navigateRequest.release());

+        ev->PrepareSend(SchemeCacheActor, SelfId());

         ctx.ExecutorThread.ActorSystem->Schedule(

             runAfter,

-            new IEventHandle(

-                SchemeCacheActor,

-                SelfId(),

-                new TEvTxProxySchemeCache::TEvNavigateKeySet(navigateRequest.release())

-            )

+            ev.Release()

         );

     }

 

diff --git a/ydb/core/ymq/actor/node_tracker.h b/ydb/core/ymq/actor/node_tracker.h
index aa4dd941615..0529589b07b 100644
--- a/ydb/core/ymq/actor/node_tracker.h
+++ b/ydb/core/ymq/actor/node_tracker.h
@@ -57,7 +57,7 @@ public:
             HFunc(TEvTabletPipe::TEvClientConnected, HandlePipeClientConnected);
             HFunc(TEvTxProxySchemeCache::TEvWatchNotifyUpdated, Handle);
         default:
-            LOG_SQS_ERROR("Unknown type of event came to SQS node tracker actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+            LOG_SQS_ERROR("Unknown type of event came to SQS node tracker actor: " << ev->Type << " (" << ev->ToString() << "), sender: " << ev->Sender);
         }
     }
 
diff --git a/ydb/core/ymq/actor/proxy_service.cpp b/ydb/core/ymq/actor/proxy_service.cpp
index ef8b250cb40..4990ac55823 100644
--- a/ydb/core/ymq/actor/proxy_service.cpp
+++ b/ydb/core/ymq/actor/proxy_service.cpp
@@ -161,7 +161,7 @@ STATEFN(TSqsProxyService::StateFunc) {
         hFunc(TEvents::TEvUndelivered,              HandleUndelivered);
         hFunc(TSqsEvents::TEvGetLeaderNodeForQueueResponse, HandleGetLeaderNodeForQueueResponse);
     default:
-        LOG_SQS_ERROR("Unknown type of event came to SQS service actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+        LOG_SQS_ERROR("Unknown type of event came to SQS service actor: " << ev->Type << " (" << ev->GetTypeName() << "), sender: " << ev->Sender);
     }
 }
 
diff --git a/ydb/core/ymq/actor/proxy_service.h b/ydb/core/ymq/actor/proxy_service.h
index e3fc2c82903..ccf223d6cfe 100644
--- a/ydb/core/ymq/actor/proxy_service.h
+++ b/ydb/core/ymq/actor/proxy_service.h
@@ -35,7 +35,7 @@ struct TReplierToSenderActorCallback : public IReplyCallback {
         RLOG_SQS_REQ_TRACE(Request->Get()->Record.GetRequestId(), "Sending sqs response: " << response);
         const TActorId selfId = TActivationContext::AsActorContext().SelfID;
         TActivationContext::Send(
-            new IEventHandle(
+            new IEventHandleFat(
                 Request->Sender,
                 selfId,
                 new TSqsEvents::TEvSqsResponse(std::move(response))));
diff --git a/ydb/core/ymq/actor/queue_leader.cpp b/ydb/core/ymq/actor/queue_leader.cpp
index 9dcb1a6bc47..0cd68ab1601 100644
--- a/ydb/core/ymq/actor/queue_leader.cpp
+++ b/ydb/core/ymq/actor/queue_leader.cpp
@@ -109,7 +109,7 @@ STATEFN(TQueueLeader::StateInit) {
         hFunc(TSqsEvents::TEvExecuted, HandleExecuted); // from executor
         hFunc(TEvWakeup, HandleWakeup);
     default:
-        LOG_SQS_ERROR("Unknown type of event came to SQS background queue " << TLogQueueName(UserName_, QueueName_) << " leader actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+        LOG_SQS_ERROR("Unknown type of event came to SQS background queue " << TLogQueueName(UserName_, QueueName_) << " leader actor: " << ev->Type << " (" << ev->GetTypeName() << "), sender: " << ev->Sender);
     }
 }
 
@@ -135,7 +135,7 @@ STATEFN(TQueueLeader::StateWorking) {
         hFunc(TSqsEvents::TEvInflyIsPurgingNotification, HandleInflyIsPurgingNotification);
         hFunc(TSqsEvents::TEvQueuePurgedNotification, HandleQueuePurgedNotification);
     default:
-        LOG_SQS_ERROR("Unknown type of event came to SQS background queue " << TLogQueueName(UserName_, QueueName_) << " leader actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+        LOG_SQS_ERROR("Unknown type of event came to SQS background queue " << TLogQueueName(UserName_, QueueName_) << " leader actor: " << ev->Type << " (" << ev->GetTypeName() << "), sender: " << ev->Sender);
     }
 }
 
@@ -892,7 +892,7 @@ void TQueueLeader::OnLoadStdMessagesBatchExecuted(ui64 shard, ui64 batchId, cons
             if (!prevRequestId || *prevRequestId != entry.RequestId) {
                 prevRequestId = &entry.RequestId;
                 RLOG_SQS_REQ_ERROR(entry.RequestId,
-                    "Batch transaction failed: " << reply << ". DlqExists=" << dlqExists << ". BatchId: " << batch->BatchId 
+                    "Batch transaction failed: " << reply << ". DlqExists=" << dlqExists << ". BatchId: " << batch->BatchId
                 );
             }
             OnLoadStdMessageResult(entry.RequestId, entry.Offset, success, nullptr, ignoreMessageLoadingErrors);
diff --git a/ydb/core/ymq/actor/queues_list_reader.cpp b/ydb/core/ymq/actor/queues_list_reader.cpp
index 09168e6d0d3..828d58e098f 100644
--- a/ydb/core/ymq/actor/queues_list_reader.cpp
+++ b/ydb/core/ymq/actor/queues_list_reader.cpp
@@ -19,7 +19,7 @@ STATEFN(TQueuesListReader::StateFunc) {
         hFunc(TSqsEvents::TEvReadQueuesList, HandleReadQueuesList);
         hFunc(TSqsEvents::TEvExecuted, HandleExecuted);
     default:
-        LOG_SQS_ERROR("Unknown type of event came to SQS user settings reader actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+        LOG_SQS_ERROR("Unknown type of event came to SQS user settings reader actor: " << ev->Type << " (" << ev->GetTypeName() << "), sender: " << ev->Sender);
     }
 }
 
diff --git a/ydb/core/ymq/actor/service.cpp b/ydb/core/ymq/actor/service.cpp
index 8dcb6122161..b42e38e8304 100644
--- a/ydb/core/ymq/actor/service.cpp
+++ b/ydb/core/ymq/actor/service.cpp
@@ -42,8 +42,8 @@
 LWTRACE_USING(SQS_PROVIDER);
 
 template <>
-struct THash<NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest::TPtr> : THash<const NActors::TEventHandle<NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest>*> {
-    using TParent = THash<const NActors::TEventHandle<NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest>*>;
+struct THash<NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest::TPtr> : THash<const NActors::TEventHandleFat<NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest>*> {
+    using TParent = THash<const NActors::TEventHandleFat<NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest>*>;
     using TParent::operator();
     size_t operator()(const NKikimr::NSQS::TSqsEvents::TEvGetLeaderNodeForQueueRequest::TPtr& ptr) const {
         return TParent::operator()(ptr.Get());
@@ -139,7 +139,7 @@ struct TSqsService::TQueueInfo : public TAtomicRefCount<TQueueInfo> {
             Counters_ = Counters_->GetCountersForNotLeaderNode();
             LWPROBE(DestroyLeader, UserName_, QueueName_, reason);
             LOG_SQS_INFO("Stop local leader [" << UserName_ << "/" << QueueName_ << "] actor " << LocalLeader_);
-            TActivationContext::Send(new IEventHandle(LocalLeader_, SelfId(), new TEvPoisonPill()));
+            TActivationContext::Send(new IEventHandleFat(LocalLeader_, SelfId(), new TEvPoisonPill()));
             LocalLeader_ = TActorId();
             if (FolderId_) {
                 Y_VERIFY(FolderCounters_);
@@ -340,7 +340,7 @@ STATEFN(TSqsService::StateFunc) {
         hFunc(TSqsEvents::TEvUserSettingsChanged, HandleUserSettingsChanged);
         hFunc(TSqsEvents::TEvQueuesList, HandleQueuesList);
     default:
-        LOG_SQS_ERROR("Unknown type of event came to SQS service actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+        LOG_SQS_ERROR("Unknown type of event came to SQS service actor: " << ev->Type << " (" << ev->GetTypeName() << "), sender: " << ev->Sender);
     }
 }
 
@@ -431,7 +431,7 @@ void TSqsService::HandleGetLeaderNodeForQueueRequest(TSqsEvents::TEvGetLeaderNod
     if (!queuePtr->LeaderNodeId_) {
         LWPROBE(QueueRequestCacheMiss, userName, queueName, reqId, ev->Get()->ToStringHeader());
         RLOG_SQS_REQ_DEBUG(reqId, "Queue [" << userName << "/" << queueName << "] is waiting for connection to leader tablet.");
-        
+
         queuePtr->GetLeaderNodeRequests_.emplace(std::move(ev));
         if (QueuesWithGetNodeWaitingRequests.empty()) {
             Schedule(
@@ -662,7 +662,7 @@ void TSqsService::HandleGetQueueId(TSqsEvents::TEvGetQueueId::TPtr& ev) {
     const auto& info = *queueIt->second;
     RLOG_SQS_REQ_DEBUG(
         reqId,
-        "Queue id is " << info.QueueName_ << " and version is " << info.Version_ 
+        "Queue id is " << info.QueueName_ << " and version is " << info.Version_
             << " with shards count: " << info.ShardsCount_ << " tables format: " << info.TablesFormat_
     );
     Send(
@@ -749,7 +749,7 @@ void TSqsService::HandleNodeTrackingSubscriptionStatus(TSqsEvents::TEvNodeTracke
     auto nodeId = ev->Get()->NodeId;
     queue.SetLeaderNodeId(nodeId);
     LOG_SQS_DEBUG(
-        "Got node leader for queue [" << queue.UserName_ << "/" << queue.QueueName_ 
+        "Got node leader for queue [" << queue.UserName_ << "/" << queue.QueueName_
         << "]. Node: " << nodeId << " subscription id: " << subscriptionId
     );
     for (auto& req : queue.GetLeaderNodeRequests_) {
@@ -1089,7 +1089,7 @@ std::map<TString, TSqsService::TQueueInfoPtr>::iterator TSqsService::AddQueue(co
         }
         user->GetQueueFolderIdAndCustomNameRequests_.erase(requests.first, requests.second);
     }
-    
+
     CreateNodeTrackingSubscription(queueInfo);
     LOG_SQS_DEBUG("Created queue record. Queue: [" << queue << "]. QueueIdNumber: " << queueInfo->Version_ << ". Leader tablet id: [" << leaderTabletId << "]. Node tracker subscription: " << queueInfo->NodeTrackingSubscriptionId);
     return ret;
@@ -1190,7 +1190,7 @@ void TSqsService::ProcessConnectTimeoutToLeader() {
         }
     }
     if (nextRunAfter != TDuration::Max()) {
-        Schedule(nextRunAfter, new TEvWakeup(CONNECT_TIMEOUT_TO_LEADER_WAKEUP_TAG)); 
+        Schedule(nextRunAfter, new TEvWakeup(CONNECT_TIMEOUT_TO_LEADER_WAKEUP_TAG));
     }
 }
 
diff --git a/ydb/core/ymq/actor/user_settings_reader.cpp b/ydb/core/ymq/actor/user_settings_reader.cpp
index 0637b655dd2..b03c1fd7101 100644
--- a/ydb/core/ymq/actor/user_settings_reader.cpp
+++ b/ydb/core/ymq/actor/user_settings_reader.cpp
@@ -23,7 +23,7 @@ STATEFN(TUserSettingsReader::StateFunc) {
         hFunc(TEvWakeup, HandleWakeup);
         hFunc(TSqsEvents::TEvExecuted, HandleExecuted);
     default:
-        LOG_SQS_ERROR("Unknown type of event came to SQS user settings reader actor: " << ev->Type << " (" << ev->GetBase()->ToString() << "), sender: " << ev->Sender);
+        LOG_SQS_ERROR("Unknown type of event came to SQS user settings reader actor: " << ev->Type << " (" << ev->ToString() << "), sender: " << ev->Sender);
     }
 }
 
diff --git a/ydb/core/ymq/actor/ut/metering_ut.cpp b/ydb/core/ymq/actor/ut/metering_ut.cpp
index bb6cbc64585..d577e10d6fb 100644
--- a/ydb/core/ymq/actor/ut/metering_ut.cpp
+++ b/ydb/core/ymq/actor/ut/metering_ut.cpp
@@ -161,7 +161,7 @@ Y_UNIT_TEST_SUITE(Metering) {
         AddRequestToQueue(requests, "5.45.215.192", 100, 200, 200);
 
         for (auto& req : requests) {
-            runtime->Send(new IEventHandle(
+            runtime->Send(new IEventHandleFat(
                 MakeSqsMeteringServiceID(), runtime->AllocateEdgeActor(), req.Release()
             ));
         }
@@ -214,7 +214,7 @@ Y_UNIT_TEST_SUITE(Metering) {
         }
 
         for (auto& req : requests) {
-            runtime->Send(new IEventHandle(
+            runtime->Send(new IEventHandleFat(
                 MakeSqsMeteringServiceID(), runtime->AllocateEdgeActor(), req.Release()
             ));
         }
@@ -240,7 +240,7 @@ Y_UNIT_TEST_SUITE(Metering) {
             auto classifierUpdateRequest = MakeHolder<NNetClassifier::TEvNetClassifier::TEvClassifierUpdate>();
             classifierUpdateRequest->Classifier = classifier;
             classifierUpdateRequest->NetDataUpdateTimestamp = TInstant::Now();
-            runtime->Send(new IEventHandle(
+            runtime->Send(new IEventHandleFat(
                 MakeSqsMeteringServiceID(), runtime->AllocateEdgeActor(), classifierUpdateRequest.Release()
             ));
         }
@@ -273,7 +273,7 @@ Y_UNIT_TEST_SUITE(Metering) {
             AddRequestToQueue(requests, "2a0d:d6c0:bbbb:bbbb:bbbb:bbbb:bbbb:bbbb", 100, 200, 200);
         }
         for (auto& req : requests) {
-            runtime->Send(new IEventHandle(
+            runtime->Send(new IEventHandleFat(
                 MakeSqsMeteringServiceID(), runtime->AllocateEdgeActor(), req.Release()
             ));
         }
@@ -320,7 +320,7 @@ Y_UNIT_TEST_SUITE(Metering) {
             auto classifierUpdateRequest = MakeHolder<NNetClassifier::TEvNetClassifier::TEvClassifierUpdate>();
             classifierUpdateRequest->Classifier = classifier;
             classifierUpdateRequest->NetDataUpdateTimestamp = TInstant::Now();
-            runtime->Send(new IEventHandle(
+            runtime->Send(new IEventHandleFat(
                 MakeSqsMeteringServiceID(), runtime->AllocateEdgeActor(), classifierUpdateRequest.Release()
             ));
         }
@@ -338,7 +338,7 @@ Y_UNIT_TEST_SUITE(Metering) {
             AddToExpectedRecords(expectedRecords, requests.back()->Data, TProcessedRequestsAggregator::ENetworkClass::cloud);
         }
         for (auto& req : requests) {
-            runtime->Send(new IEventHandle(
+            runtime->Send(new IEventHandleFat(
                 MakeSqsMeteringServiceID(), runtime->AllocateEdgeActor(), req.Release()
             ));
         }
diff --git a/ydb/core/ymq/actor/yc_search_ut/index_events_processor_ut.cpp b/ydb/core/ymq/actor/yc_search_ut/index_events_processor_ut.cpp
index 59269b45907..4d7bda81d7a 100644
--- a/ydb/core/ymq/actor/yc_search_ut/index_events_processor_ut.cpp
+++ b/ydb/core/ymq/actor/yc_search_ut/index_events_processor_ut.cpp
@@ -71,7 +71,7 @@ private:
         }
         ~TTestRunner() {
             if (Processor != nullptr) {
-                auto handle = new IEventHandle(ProcessorId, TActorId(), new TEvents::TEvPoisonPill());
+                auto handle = new IEventHandleFat(ProcessorId, TActorId(), new TEvents::TEvPoisonPill());
                 Parent->Server->GetRuntime()->Send(handle);
             }
         }
@@ -228,7 +228,7 @@ private:
             auto initialCount = Processor->GetReindexCount();
             DispatchOpts.CustomFinalCondition = [initialCount, processor = Processor]() { return processor->GetReindexCount() > initialCount; };
             if (!initialCount) {
-                auto handle = new IEventHandle(ProcessorId, TActorId(), new TEvWakeup());
+                auto handle = new IEventHandleFat(ProcessorId, TActorId(), new TEvWakeup());
                 Parent->Server->GetRuntime()->Send(handle);
             }
             Parent->Server->GetRuntime()->DispatchEvents(DispatchOpts, TDuration::Minutes(1));
diff --git a/ydb/core/ymq/base/run_query.cpp b/ydb/core/ymq/base/run_query.cpp
index 9525c5edd10..38bdf69cbf9 100644
--- a/ydb/core/ymq/base/run_query.cpp
+++ b/ydb/core/ymq/base/run_query.cpp
@@ -41,9 +41,9 @@ namespace NKikimr::NSQS {
         if (sendAfter == TDuration::Zero()) {

             ctx.Send(kqpActor, ev.Release());

         } else {

-            ctx.ExecutorThread.Schedule(sendAfter, new IEventHandle(kqpActor, ctx.SelfID, ev.Release()));

+            ctx.ExecutorThread.Schedule(sendAfter, new IEventHandleFat(kqpActor, ctx.SelfID, ev.Release()));

         }

     }

-    

-    

+

+

 } // namespace NKikimr::NSQS

diff --git a/ydb/core/yq/libs/actors/database_resolver.cpp b/ydb/core/yq/libs/actors/database_resolver.cpp
index 231b2af8ce2..14afa0be4bc 100644
--- a/ydb/core/yq/libs/actors/database_resolver.cpp
+++ b/ydb/core/yq/libs/actors/database_resolver.cpp
@@ -343,7 +343,7 @@ private:
                     new TResponseProcessor(ev->Sender, Cache, ready, requests, TraceId, ev->Get()->MdbTransformHost, Parsers));
 
             for (const auto& [request, _] : requests) {
-                TActivationContext::Send(new IEventHandle(HttpProxy, helper, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(request)));
+                TActivationContext::Send(new IEventHandleFat(HttpProxy, helper, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(request)));
             }
         } else {
             SendResponse(ev->Sender, std::move(ready));
diff --git a/ydb/core/yq/libs/checkpointing/ut/checkpoint_coordinator_ut.cpp b/ydb/core/yq/libs/checkpointing/ut/checkpoint_coordinator_ut.cpp
index 96e2d697a82..5647471df99 100644
--- a/ydb/core/yq/libs/checkpointing/ut/checkpoint_coordinator_ut.cpp
+++ b/ydb/core/yq/libs/checkpointing/ut/checkpoint_coordinator_ut.cpp
@@ -111,7 +111,7 @@ struct TTestBootstrap : public TTestActorRuntime {
             TDuration::Seconds(3),
             TDuration::Seconds(1)
         ).Release());
-        Send(new IEventHandle(CheckpointCoordinator, {}, new NYql::NDqs::TEvReadyState(std::move(GraphState))));
+        Send(new IEventHandleFat(CheckpointCoordinator, {}, new NYql::NDqs::TEvReadyState(std::move(GraphState))));
 
         EnableScheduleForActor(CheckpointCoordinator);
     }
@@ -122,21 +122,21 @@ struct TTestBootstrap : public TTestActorRuntime {
 namespace NYq {
 
 void MockRegisterCoordinatorResponseEvent(TTestBootstrap& bootstrap, NYql::TIssues issues = NYql::TIssues()) {
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         bootstrap.StorageProxy,
         new TEvCheckpointStorage::TEvRegisterCoordinatorResponse(std::move(issues))));
 }
 
 void MockCheckpointsMetadataResponse(TTestBootstrap& bootstrap, NYql::TIssues issues = NYql::TIssues()) {
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         bootstrap.StorageProxy,
         new TEvCheckpointStorage::TEvGetCheckpointsMetadataResponse(TVector<TCheckpointMetadata>(), std::move(issues))));
 }
 
 void MockCreateCheckpointResponse(TTestBootstrap& bootstrap, TCheckpointId& checkpointId, NYql::TIssues issues = NYql::TIssues()) {
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         bootstrap.StorageProxy,
         new TEvCheckpointStorage::TEvCreateCheckpointResponse(checkpointId, std::move(issues), "42")));
@@ -147,7 +147,7 @@ void MockNodeStateSavedEvent(TTestBootstrap& bootstrap, TCheckpointId& checkpoin
     ev->Record.MutableCheckpoint()->SetGeneration(checkpointId.CoordinatorGeneration);
     ev->Record.MutableCheckpoint()->SetId(checkpointId.SeqNo);
     ev->Record.SetStatus(NYql::NDqProto::TEvSaveTaskStateResult::OK);
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         sender,
         ev.release()));
@@ -158,28 +158,28 @@ void MockNodeStateSaveFailedEvent(TTestBootstrap& bootstrap, TCheckpointId& chec
     ev->Record.MutableCheckpoint()->SetGeneration(checkpointId.CoordinatorGeneration);
     ev->Record.MutableCheckpoint()->SetId(checkpointId.SeqNo);
     ev->Record.SetStatus(NYql::NDqProto::TEvSaveTaskStateResult::STORAGE_ERROR);
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         sender,
         ev.release()));
 }
 
 void MockSetCheckpointPendingCommitStatusResponse(TTestBootstrap& bootstrap, TCheckpointId& checkpointId, NYql::TIssues issues = NYql::TIssues()) {
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         bootstrap.StorageProxy,
         new TEvCheckpointStorage::TEvSetCheckpointPendingCommitStatusResponse(checkpointId, std::move(issues))));
 }
 
 void MockChangesCommittedEvent(TTestBootstrap& bootstrap, TCheckpointId& checkpointId, TActorId& sender) {
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         sender,
         new NYql::NDq::TEvDqCompute::TEvStateCommitted(checkpointId.SeqNo, checkpointId.CoordinatorGeneration, bootstrap.ActorToTask[sender])));
 }
 
 void MockCompleteCheckpointResponse(TTestBootstrap& bootstrap, TCheckpointId& checkpointId, NYql::TIssues issues = NYql::TIssues()) {
-    bootstrap.Send(new IEventHandle(
+    bootstrap.Send(new IEventHandleFat(
         bootstrap.CheckpointCoordinator,
         bootstrap.StorageProxy,
         new TEvCheckpointStorage::TEvCompleteCheckpointResponse(checkpointId, std::move(issues))));
diff --git a/ydb/core/yq/libs/cloud_audit/yq_cloud_audit_service.cpp b/ydb/core/yq/libs/cloud_audit/yq_cloud_audit_service.cpp
index 11d828f7b3d..2132fcf3c67 100644
--- a/ydb/core/yq/libs/cloud_audit/yq_cloud_audit_service.cpp
+++ b/ydb/core/yq/libs/cloud_audit/yq_cloud_audit_service.cpp
@@ -276,7 +276,7 @@ private:
                 AuditServiceSensors->ReportCloudIdResolvedRetry();
                 LOG_YQ_AUDIT_SERVICE_ERROR("Folder resolve error. Retry with delay " << *delay << ", EventId: " << *EventId << " cloud id resolve error. "
                     << "Status " << status.GRpcStatusCode << " " << status.Msg << " details: " << status.Details);
-                NActors::TActivationContext::Schedule(*delay, new IEventHandle(NKikimr::NFolderService::FolderServiceActorId(), Base::SelfId(), CreateRequest().release()));
+                NActors::TActivationContext::Schedule(*delay, new IEventHandleFat(NKikimr::NFolderService::FolderServiceActorId(), Base::SelfId(), CreateRequest().release()));
                 return;
             }
             AuditServiceSensors->ReportCloudIdResolvedError();
diff --git a/ydb/core/yq/libs/control_plane_proxy/control_plane_proxy.cpp b/ydb/core/yq/libs/control_plane_proxy/control_plane_proxy.cpp
index 0c098fa72e0..5a410b93b76 100644
--- a/ydb/core/yq/libs/control_plane_proxy/control_plane_proxy.cpp
+++ b/ydb/core/yq/libs/control_plane_proxy/control_plane_proxy.cpp
@@ -316,7 +316,7 @@ public:
             if (delay) {
                 Counters->Retry->Inc();
                 CPP_LOG_E("Folder resolve error. Retry with delay " << *delay << ", " << errorMessage);
-                TActivationContext::Schedule(*delay, new IEventHandle(NKikimr::NFolderService::FolderServiceActorId(), static_cast<const TActorId&>(SelfId()), CreateRequest().release()));
+                TActivationContext::Schedule(*delay, new IEventHandleFat(NKikimr::NFolderService::FolderServiceActorId(), static_cast<const TActorId&>(SelfId()), CreateRequest().release()));
                 return;
             }
             Counters->Error->Inc();
diff --git a/ydb/core/yq/libs/control_plane_proxy/ut/control_plane_proxy_ut.cpp b/ydb/core/yq/libs/control_plane_proxy/ut/control_plane_proxy_ut.cpp
index 12878629966..38b07decd0a 100644
--- a/ydb/core/yq/libs/control_plane_proxy/ut/control_plane_proxy_ut.cpp
+++ b/ydb/core/yq/libs/control_plane_proxy/ut/control_plane_proxy_ut.cpp
@@ -116,7 +116,7 @@ struct TTestBootstrap {
         proto.mutable_content()->set_name("my_query_name");
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvCreateQueryRequest>("", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
         if (processCreateRateLimiterResource) {
             auto req = RateLimiterGrab->GetRequest();
@@ -130,14 +130,14 @@ struct TTestBootstrap {
     }
 
     void SendCreateRateLimiterResourceSuccess(const TActorId& id, const TString& rateLimiter = "rate_limiter") {
-        Runtime->Send(new IEventHandle(id, id, new TEvRateLimiter::TEvCreateResourceResponse(rateLimiter, NYql::TIssues())));
+        Runtime->Send(new IEventHandleFat(id, id, new TEvRateLimiter::TEvCreateResourceResponse(rateLimiter, NYql::TIssues())));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
     void SendCreateRateLimiterResourceError(const TActorId& id) {
         NYql::TIssues issues;
         issues.AddIssue("Trololo");
-        Runtime->Send(new IEventHandle(id, id, new TEvRateLimiter::TEvCreateResourceResponse(issues)));
+        Runtime->Send(new IEventHandleFat(id, id, new TEvRateLimiter::TEvCreateResourceResponse(issues)));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -147,7 +147,7 @@ struct TTestBootstrap {
         YandexQuery::ListQueriesRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvListQueriesRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -157,7 +157,7 @@ struct TTestBootstrap {
         YandexQuery::DescribeQueryRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDescribeQueryRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -167,7 +167,7 @@ struct TTestBootstrap {
         YandexQuery::GetQueryStatusRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvGetQueryStatusRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -177,7 +177,7 @@ struct TTestBootstrap {
         YandexQuery::ModifyQueryRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvModifyQueryRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -187,7 +187,7 @@ struct TTestBootstrap {
         YandexQuery::DeleteQueryRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDeleteQueryRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -197,7 +197,7 @@ struct TTestBootstrap {
         YandexQuery::ControlQueryRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvControlQueryRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -207,7 +207,7 @@ struct TTestBootstrap {
         YandexQuery::GetResultDataRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvGetResultDataRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -218,7 +218,7 @@ struct TTestBootstrap {
         proto.set_query_id("my_query_id");
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvListJobsRequest>("", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -228,7 +228,7 @@ struct TTestBootstrap {
         YandexQuery::DescribeJobRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDescribeJobRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -246,7 +246,7 @@ struct TTestBootstrap {
         }
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvCreateConnectionRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -256,7 +256,7 @@ struct TTestBootstrap {
         YandexQuery::ListConnectionsRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvListConnectionsRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -266,7 +266,7 @@ struct TTestBootstrap {
         YandexQuery::DescribeConnectionRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDescribeConnectionRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -284,7 +284,7 @@ struct TTestBootstrap {
         }
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvModifyConnectionRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -294,7 +294,7 @@ struct TTestBootstrap {
         YandexQuery::DeleteConnectionRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDeleteConnectionRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -311,7 +311,7 @@ struct TTestBootstrap {
         }
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvTestConnectionRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -321,7 +321,7 @@ struct TTestBootstrap {
         YandexQuery::CreateBindingRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvCreateBindingRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -331,7 +331,7 @@ struct TTestBootstrap {
         YandexQuery::ListBindingsRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvListBindingsRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -341,7 +341,7 @@ struct TTestBootstrap {
         YandexQuery::DescribeBindingRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDescribeBindingRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -351,7 +351,7 @@ struct TTestBootstrap {
         YandexQuery::ModifyBindingRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvModifyBindingRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
@@ -361,7 +361,7 @@ struct TTestBootstrap {
         YandexQuery::DeleteBindingRequest proto;
 
         auto request = std::make_unique<TEvControlPlaneProxy::TEvDeleteBindingRequest>("my_folder", proto, user, "", permissions);
-        Runtime->Send(new IEventHandle(ControlPlaneProxyActorId(), sender, request.release()));
+        Runtime->Send(new IEventHandleFat(ControlPlaneProxyActorId(), sender, request.release()));
         Runtime->DispatchEvents({}, TDuration::Zero());
     }
 
diff --git a/ydb/core/yq/libs/control_plane_storage/in_memory_control_plane_storage.cpp b/ydb/core/yq/libs/control_plane_storage/in_memory_control_plane_storage.cpp
index 85e7fd5f488..4a28a547fd4 100644
--- a/ydb/core/yq/libs/control_plane_storage/in_memory_control_plane_storage.cpp
+++ b/ydb/core/yq/libs/control_plane_storage/in_memory_control_plane_storage.cpp
@@ -300,7 +300,7 @@ private:
         CPS_LOG_I("GetTaskRequest");
         Fq::Private::GetTaskResult result;
         auto event = std::make_unique<TEvControlPlaneStorage::TEvGetTaskResponse>(result);
-        NActors::TActivationContext::ActorSystem()->Send(new IEventHandle(ev->Sender, SelfId(), event.release(), 0, ev->Cookie));
+        NActors::TActivationContext::ActorSystem()->Send(new IEventHandleFat(ev->Sender, SelfId(), event.release(), 0, ev->Cookie));
     }
 
     void Handle(TEvControlPlaneStorage::TEvPingTaskRequest::TPtr& ev)
@@ -330,7 +330,7 @@ private:
 
         TResult result = {};
         auto event = std::make_unique<TEvResult>(result);
-        NActors::TActivationContext::ActorSystem()->Send(new IEventHandle(ev->Sender, SelfId(), event.release(), 0, ev->Cookie));
+        NActors::TActivationContext::ActorSystem()->Send(new IEventHandleFat(ev->Sender, SelfId(), event.release(), 0, ev->Cookie));
     }
 
     template<typename TRequest, typename TResult, typename TEvResult, typename TAuditDetails>
@@ -340,7 +340,7 @@ private:
         TResult result = {};
         TAuditDetails auditDetails = {};
         auto event = std::make_unique<TEvResult>(result, auditDetails);
-        NActors::TActivationContext::ActorSystem()->Send(new IEventHandle(ev->Sender, SelfId(), event.release(), 0, ev->Cookie));
+        NActors::TActivationContext::ActorSystem()->Send(new IEventHandleFat(ev->Sender, SelfId(), event.release(), 0, ev->Cookie));
     }
 
     NYql::TIssues ValidateCreateQueryRequest(TEvControlPlaneStorage::TEvCreateQueryRequest::TPtr& ev)
diff --git a/ydb/core/yq/libs/control_plane_storage/request_actor.h b/ydb/core/yq/libs/control_plane_storage/request_actor.h
index 7b40bbd00ec..8fc12f1b8e2 100644
--- a/ydb/core/yq/libs/control_plane_storage/request_actor.h
+++ b/ydb/core/yq/libs/control_plane_storage/request_actor.h
@@ -168,7 +168,7 @@ protected:
     void Subscribe(NYdb::TAsyncStatus& status, std::shared_ptr<TVector<NYdb::TResultSet>> resultSets = nullptr) {
         status.Subscribe(
             [actorSystem = NActors::TActivationContext::ActorSystem(), selfId = this->SelfId(), resultSets] (const NYdb::TAsyncStatus& status) mutable {
-                actorSystem->Send(new IEventHandle(selfId, selfId, new TEvControlPlaneStorageInternal::TEvDbRequestResult(status, std::move(resultSets))));
+                actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvControlPlaneStorageInternal::TEvDbRequestResult(status, std::move(resultSets))));
             }
         );
     }
diff --git a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h
index 0953b56f2c1..ea7b6576c3a 100644
--- a/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h
+++ b/ydb/core/yq/libs/control_plane_storage/ydb_control_plane_storage_impl.h
@@ -748,7 +748,7 @@ private:
                 auto event = std::make_unique<ResponseEvent>(issues);
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
-                actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
+                actorSystem->Send(new IEventHandleFat(ev->Sender, self, event.release(), 0, ev->Cookie));
                 requestCounters.IncError();
                 for (const auto& issue : issues) {
                     NYql::WalkThroughIssues(issue, true, [&requestCounters](const NYql::TIssue& err, ui16 level) {
@@ -766,7 +766,7 @@ private:
                 }
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
-                actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
+                actorSystem->Send(new IEventHandleFat(ev->Sender, self, event.release(), 0, ev->Cookie));
                 requestCounters.IncOk();
             }
             requestCounters.DecInFly();
@@ -823,7 +823,7 @@ private:
                 std::unique_ptr<ResponseEvent> event(new ResponseEvent(issues));
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
-                actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
+                actorSystem->Send(new IEventHandleFat(ev->Sender, self, event.release(), 0, ev->Cookie));
                 requestCounters.IncError();
                 for (const auto& issue : issues) {
                     NYql::WalkThroughIssues(issue, true, [&requestCounters](const NYql::TIssue& err, ui16 level) {
@@ -836,7 +836,7 @@ private:
                 std::unique_ptr<ResponseEvent> event(new ResponseEvent(std::make_from_tuple<ResponseEvent>(result)));
                 event->DebugInfo = debugInfo;
                 responseByteSize = event->GetByteSize();
-                actorSystem->Send(new IEventHandle(ev->Sender, self, event.release(), 0, ev->Cookie));
+                actorSystem->Send(new IEventHandleFat(ev->Sender, self, event.release(), 0, ev->Cookie));
                 requestCounters.IncOk();
             }
             requestCounters.IncInFly();
diff --git a/ydb/core/yq/libs/db_id_async_resolver_impl/db_async_resolver_impl.cpp b/ydb/core/yq/libs/db_id_async_resolver_impl/db_async_resolver_impl.cpp
index b6a116be8c0..c5099284a5f 100644
--- a/ydb/core/yq/libs/db_id_async_resolver_impl/db_async_resolver_impl.cpp
+++ b/ydb/core/yq/libs/db_id_async_resolver_impl/db_async_resolver_impl.cpp
@@ -26,7 +26,7 @@ TFuture<NYql::TDbResolverResponse> TDatabaseAsyncResolverImpl::ResolveIds(
     auto promise = NewPromise<NYql::TDbResolverResponse>();
     TDuration timeout = TDuration::Seconds(40);
     auto callback = MakeHolder<NYql::TRichActorFutureCallback<TEvents::TEvEndpointResponse>>(
-        [promise] (TAutoPtr<NActors::TEventHandle<TEvents::TEvEndpointResponse>>& event) mutable {
+        [promise] (TAutoPtr<NActors::TEventHandleFat<TEvents::TEvEndpointResponse>>& event) mutable {
             promise.SetValue(std::move(event->Get()->DbResolverResponse));
         },
         [promise, timeout] () mutable {
@@ -37,7 +37,7 @@ TFuture<NYql::TDbResolverResponse> TDatabaseAsyncResolverImpl::ResolveIds(
 
     NActors::TActorId callbackId = ActorSystem->Register(callback.Release());
 
-    ActorSystem->Send(new NActors::IEventHandle(Recipient, callbackId,
+    ActorSystem->Send(new NActors::IEventHandleFat(Recipient, callbackId,
         new TEvents::TEvEndpointRequest(ids, YdbMvpEndpoint, MdbGateway,
             TraceId, MdbTransformHost)));
     return promise.GetFuture();
diff --git a/ydb/core/yq/libs/gateway/empty_gateway.cpp b/ydb/core/yq/libs/gateway/empty_gateway.cpp
index bc145f74eb4..8157deba47a 100644
--- a/ydb/core/yq/libs/gateway/empty_gateway.cpp
+++ b/ydb/core/yq/libs/gateway/empty_gateway.cpp
@@ -66,7 +66,7 @@ public:
         auto event = MakeHolder<TEvents::TEvGraphParams>(params);
         event->IsEvaluation = FromString<bool>(queryParams.Value("Evaluation", "false")) || FromString<bool>(queryParams.Value("Precompute", "false"));
         event->Result = result;
-        NActors::TActivationContext::Send(new NActors::IEventHandle(RunActorId, {}, event.Release()));
+        NActors::TActivationContext::Send(new NActors::IEventHandleFat(RunActorId, {}, event.Release()));
 
         return result;
     }
diff --git a/ydb/core/yq/libs/logs/log.cpp b/ydb/core/yq/libs/logs/log.cpp
index 65371ef058c..cedb9cd7bc9 100644
--- a/ydb/core/yq/libs/logs/log.cpp
+++ b/ydb/core/yq/libs/logs/log.cpp
@@ -45,7 +45,7 @@ private:
             hFunc(NConsole::TEvConsole::TEvConfigNotificationRequest, Handle);
         default:
             Y_FAIL("TYqlLogsUpdater: unexpected event type: %" PRIx32 " event: %s",
-                ev->GetTypeRewrite(), ev->HasEvent() ? ev->GetBase()->ToString().data() : "serialized?");
+                ev->GetTypeRewrite(), ev->ToString().data());
         }
     }
 
diff --git a/ydb/core/yq/libs/mock/yql_mock.cpp b/ydb/core/yq/libs/mock/yql_mock.cpp
index ba17d98101d..8e2e0449751 100644
--- a/ydb/core/yq/libs/mock/yql_mock.cpp
+++ b/ydb/core/yq/libs/mock/yql_mock.cpp
@@ -78,11 +78,11 @@ void InitTest(NActors::TTestActorRuntime* runtime, int httpPort, int grpcPort, c
 
     TActorId mockActorId = runtime->Register(CreateYqlMockActor(grpcPort));
 
-    runtime->Send(new NActors::IEventHandle(
+    runtime->Send(new NActors::IEventHandleFat(
                       httpProxyId, TActorId(),
                       new NHttp::TEvHttpProxy::TEvAddListeningPort(httpPort)), 0, true);
 
-    runtime->Send(new NActors::IEventHandle(
+    runtime->Send(new NActors::IEventHandleFat(
                       httpProxyId, TActorId(),
                       new NHttp::TEvHttpProxy::TEvRegisterHandler("/yql-mock/abc/database", mockActorId)),
                   0, true);
diff --git a/ydb/core/yq/libs/private_client/internal_service.cpp b/ydb/core/yq/libs/private_client/internal_service.cpp
index 23b8d313903..531746d1813 100644
--- a/ydb/core/yq/libs/private_client/internal_service.cpp
+++ b/ydb/core/yq/libs/private_client/internal_service.cpp
@@ -66,9 +66,9 @@ private:
             .NodesHealthCheck(std::move(ev->Get()->Request))
             .Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), senderId = ev->Sender, selfId = SelfId(), cookie = ev->Cookie](const NThreading::TFuture<TNodesHealthCheckResult>& future) {
                 try {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvHealthCheckResponse(future.GetValue()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvHealthCheckResponse(future.GetValue()), 0, cookie));
                 } catch (...) {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvHealthCheckResponse(CurrentExceptionMessage()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvHealthCheckResponse(CurrentExceptionMessage()), 0, cookie));
                 }
             });
     }
@@ -79,9 +79,9 @@ private:
             .GetTask(std::move(ev->Get()->Request))
             .Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), senderId = ev->Sender, selfId = SelfId(), cookie = ev->Cookie](const NThreading::TFuture<TGetTaskResult>& future) {
                 try {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvGetTaskResponse(future.GetValue()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvGetTaskResponse(future.GetValue()), 0, cookie));
                 } catch (...) {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvGetTaskResponse(CurrentExceptionMessage()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvGetTaskResponse(CurrentExceptionMessage()), 0, cookie));
                 }
             });
     }
@@ -92,9 +92,9 @@ private:
             .PingTask(std::move(ev->Get()->Request))
             .Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), senderId = ev->Sender, selfId = SelfId(), cookie = ev->Cookie](const NThreading::TFuture<TPingTaskResult>& future) {
                 try {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvPingTaskResponse(future.GetValue()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvPingTaskResponse(future.GetValue()), 0, cookie));
                 } catch (...) {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvPingTaskResponse(CurrentExceptionMessage()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvPingTaskResponse(CurrentExceptionMessage()), 0, cookie));
                 }
             });
     }
@@ -105,9 +105,9 @@ private:
             .WriteTaskResult(std::move(ev->Get()->Request))
             .Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), senderId = ev->Sender, selfId = SelfId(), cookie = ev->Cookie](const auto& future) {
                 try {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvWriteResultResponse(future.GetValue()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvWriteResultResponse(future.GetValue()), 0, cookie));
                 } catch (...) {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvWriteResultResponse(CurrentExceptionMessage()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvWriteResultResponse(CurrentExceptionMessage()), 0, cookie));
                 }
             });
     }
@@ -118,9 +118,9 @@ private:
             .CreateRateLimiterResource(std::move(ev->Get()->Request))
             .Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), senderId = ev->Sender, selfId = SelfId(), cookie = ev->Cookie](const NThreading::TFuture<TCreateRateLimiterResourceResult>& future) {
                 try {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvCreateRateLimiterResourceResponse(future.GetValue()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvCreateRateLimiterResourceResponse(future.GetValue()), 0, cookie));
                 } catch (...) {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvCreateRateLimiterResourceResponse(CurrentExceptionMessage()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvCreateRateLimiterResourceResponse(CurrentExceptionMessage()), 0, cookie));
                 }
             });
     }
@@ -131,9 +131,9 @@ private:
             .DeleteRateLimiterResource(std::move(ev->Get()->Request))
             .Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), senderId = ev->Sender, selfId = SelfId(), cookie = ev->Cookie](const NThreading::TFuture<TDeleteRateLimiterResourceResult>& future) {
                 try {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvDeleteRateLimiterResourceResponse(future.GetValue()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvDeleteRateLimiterResourceResponse(future.GetValue()), 0, cookie));
                 } catch (...) {
-                    actorSystem->Send(new NActors::IEventHandle(senderId, selfId, new TEvInternalService::TEvDeleteRateLimiterResourceResponse(CurrentExceptionMessage()), 0, cookie));
+                    actorSystem->Send(new NActors::IEventHandleFat(senderId, selfId, new TEvInternalService::TEvDeleteRateLimiterResourceResponse(CurrentExceptionMessage()), 0, cookie));
                 }
             });
     }
diff --git a/ydb/core/yq/libs/quota_manager/quota_manager.cpp b/ydb/core/yq/libs/quota_manager/quota_manager.cpp
index aedfd6b5cb1..b452299c006 100644
--- a/ydb/core/yq/libs/quota_manager/quota_manager.cpp
+++ b/ydb/core/yq/libs/quota_manager/quota_manager.cpp
@@ -228,7 +228,7 @@ private:
         if (oldPeerCount != NodeIds.size()) {
             LOG_D("IC Peers[" << NodeIds.size() << "]: " << ToString(NodeIds));
         }
-        NActors::TActivationContext::Schedule(TDuration::Seconds(NodeIds.empty() ? 1 : 5), new IEventHandle(NActors::GetNameserviceActorId(), SelfId(), new NActors::TEvInterconnect::TEvListNodes()));
+        NActors::TActivationContext::Schedule(TDuration::Seconds(NodeIds.empty() ? 1 : 5), new IEventHandleFat(NActors::GetNameserviceActorId(), SelfId(), new NActors::TEvInterconnect::TEvListNodes()));
     }
 
     void Handle(TEvQuotaService::TQuotaGetRequest::TPtr& ev) {
diff --git a/ydb/core/yq/libs/rate_limiter/quoter_service/quoter_service.cpp b/ydb/core/yq/libs/rate_limiter/quoter_service/quoter_service.cpp
index 98ff1642ade..f699dd36262 100644
--- a/ydb/core/yq/libs/rate_limiter/quoter_service/quoter_service.cpp
+++ b/ydb/core/yq/libs/rate_limiter/quoter_service/quoter_service.cpp
@@ -143,7 +143,7 @@ public:
         LOG_T("Send acquire resource request to {\"" << key.first << "\", \"" << key.second << "\"}. Amount: " << amount << ". Cookie: " << cookie);
         auto asyncStatus = YdbConnection->RateLimiterClient.AcquireResource(key.first, key.second, NYdb::NRateLimiter::TAcquireResourceSettings().Amount(amount));
         asyncStatus.Subscribe([actorSystem = NActors::TActivationContext::ActorSystem(), selfId = SelfId(), cookie, key, amount](const NYdb::TAsyncStatus& status) {
-            actorSystem->Send(new NActors::IEventHandle(selfId, selfId, new TEvPrivate::TEvQuotaReceived(status.GetValueSync(), key.first, key.second, amount), 0, cookie));
+            actorSystem->Send(new NActors::IEventHandleFat(selfId, selfId, new TEvPrivate::TEvQuotaReceived(status.GetValueSync(), key.first, key.second, amount), 0, cookie));
         });
     }
 
diff --git a/ydb/core/yq/libs/test_connection/test_data_streams.cpp b/ydb/core/yq/libs/test_connection/test_data_streams.cpp
index c4973c8d743..5a0d551f33b 100644
--- a/ydb/core/yq/libs/test_connection/test_data_streams.cpp
+++ b/ydb/core/yq/libs/test_connection/test_data_streams.cpp
@@ -150,9 +150,9 @@ private:
         DbResolver->ResolveIds(ids).Apply([self=SelfId(), as=TActivationContext::ActorSystem()](const auto& future) {
             try {
                 auto result = future.GetValue();
-                as->Send(new IEventHandle(self, self, new TEvPrivate::TEvResolveDbResponse(result), 0));
+                as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvResolveDbResponse(result), 0));
             } catch (...) {
-                as->Send(new IEventHandle(self, self, new TEvPrivate::TEvResolveDbResponse(NYql::TDbResolverResponse{{}, false, NYql::TIssues{MakeErrorIssue(NYq::TIssuesIds::BAD_REQUEST, CurrentExceptionMessage())}}), 0));
+                as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvResolveDbResponse(NYql::TDbResolverResponse{{}, false, NYql::TIssues{MakeErrorIssue(NYq::TIssuesIds::BAD_REQUEST, CurrentExceptionMessage())}}), 0));
             }
         });
     }
@@ -184,9 +184,9 @@ private:
         Gateway->OpenSession(SessionName, {}).Apply([self=SelfId(), as=TActivationContext::ActorSystem()](const auto& future) {
             try {
                 future.TryRethrow();
-                as->Send(new IEventHandle(self, self, new TEvPrivate::TEvOpenSessionResponse(), 0));
+                as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvOpenSessionResponse(), 0));
             } catch (...) {
-                as->Send(new IEventHandle(self, self, new TEvPrivate::TEvOpenSessionResponse(CurrentExceptionMessage()), 0));
+                as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvOpenSessionResponse(CurrentExceptionMessage()), 0));
             }
         });
     }
@@ -206,9 +206,9 @@ private:
         Gateway->ListStreams(SessionName, SessionName, ClusterConfig.GetDatabase(), StructuredToken, 1).Apply([self=SelfId(), as=TActivationContext::ActorSystem()](const auto& future) {
             try {
                 future.TryRethrow();
-                as->Send(new IEventHandle(self, self, new TEvPrivate::TEvCheckListStreamsResponse(), 0));
+                as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvCheckListStreamsResponse(), 0));
             } catch (...) {
-                as->Send(new IEventHandle(self, self, new TEvPrivate::TEvCheckListStreamsResponse(CurrentExceptionMessage()), 0));
+                as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvCheckListStreamsResponse(CurrentExceptionMessage()), 0));
             }
         });
     }
diff --git a/ydb/core/yq/libs/test_connection/test_object_storage.cpp b/ydb/core/yq/libs/test_connection/test_object_storage.cpp
index 68b96fee122..82cf4b217ed 100644
--- a/ydb/core/yq/libs/test_connection/test_object_storage.cpp
+++ b/ydb/core/yq/libs/test_connection/test_object_storage.cpp
@@ -119,11 +119,11 @@ public:
 
 private:
     static void SendError(TActorId self, NActors::TActorSystem* as, const TString& errorMessage, const TString& requestId) {
-        as->Send(new IEventHandle(self, self, new TEvPrivate::TEvDiscoveryResponse(errorMessage, requestId), 0));
+        as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvDiscoveryResponse(errorMessage, requestId), 0));
     }
 
     static void SendOk(TActorId self, NActors::TActorSystem* as, const TString& requestId) {
-        as->Send(new IEventHandle(self, self, new TEvPrivate::TEvDiscoveryResponse(requestId), 0));
+        as->Send(new IEventHandleFat(self, self, new TEvPrivate::TEvDiscoveryResponse(requestId), 0));
     }
 
     static void DiscoveryCallback(NYql::IHTTPGateway::TResult&& result, TActorId self, const TString& requestId, NActors::TActorSystem* as) {
diff --git a/ydb/library/db_pool/db_pool.cpp b/ydb/library/db_pool/db_pool.cpp
index 50cd7030592..7db5765615c 100644
--- a/ydb/library/db_pool/db_pool.cpp
+++ b/ydb/library/db_pool/db_pool.cpp
@@ -82,7 +82,7 @@ public:
             }, settings)
             .Subscribe([state = std::weak_ptr<int>(State), sharedResult, actorSystem = TActivationContext::ActorSystem(), cookie, selfId = SelfId()](const NThreading::TFuture<NYdb::TStatus>& statusFuture) {
                 if (state.lock()) {
-                    actorSystem->Send(new IEventHandle(selfId, selfId, new TEvents::TEvDbResponse(statusFuture.GetValue(), *sharedResult), 0, cookie));
+                    actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvents::TEvDbResponse(statusFuture.GetValue(), *sharedResult), 0, cookie));
                 } else {
                     LOG_T_AS(actorSystem, "TDbPoolActor: ProcessQueue " << selfId << " State destroyed");
                 }
@@ -95,7 +95,7 @@ public:
             })
             .Subscribe([state = std::weak_ptr<int>(State), actorSystem = TActivationContext::ActorSystem(), selfId = SelfId(), cookie](const NThreading::TFuture<NYdb::TStatus>& statusFuture) {
                 if (state.lock()) {
-                    actorSystem->Send(new IEventHandle(selfId, selfId, new TEvents::TEvDbFunctionResponse(statusFuture.GetValue()), 0, cookie));
+                    actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvents::TEvDbFunctionResponse(statusFuture.GetValue()), 0, cookie));
                 } else {
                     LOG_T_AS(actorSystem, "TDbPoolActor: ProcessQueue " << selfId << " State destroyed");
                 }
@@ -200,7 +200,7 @@ TDbPool::TDbPool(
 void TDbPool::Cleanup() {
     auto parentId = NActors::TActivationContext::AsActorContext().SelfID;
     for (const auto& actorId : Actors) {
-        NActors::TActivationContext::Send(new IEventHandle(actorId, parentId, new NActors::TEvents::TEvPoison()));
+        NActors::TActivationContext::Send(new IEventHandleFat(actorId, parentId, new NActors::TEvents::TEvPoison()));
     }
 }
 
diff --git a/ydb/library/ycloud/impl/access_service_ut.cpp b/ydb/library/ycloud/impl/access_service_ut.cpp
index c4dc207b4ca..8d9b1fe9bda 100644
--- a/ydb/library/ycloud/impl/access_service_ut.cpp
+++ b/ydb/library/ycloud/impl/access_service_ut.cpp
@@ -75,7 +75,7 @@ Y_UNIT_TEST_SUITE(TAccessServiceTest) {
         // check for not found
         auto request = MakeHolder<NCloud::TEvAccessService::TEvAuthenticateRequest>();
         request->Request.set_iam_token("bad1");
-        setup.GetRuntime()->Send(new IEventHandle(setup.AccessServiceActor->SelfId(), setup.EdgeActor, request.Release()));
+        setup.GetRuntime()->Send(new IEventHandleFat(setup.AccessServiceActor->SelfId(), setup.EdgeActor, request.Release()));
         auto result = setup.GetRuntime()->GrabEdgeEvent<NCloud::TEvAccessService::TEvAuthenticateResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT_VALUES_EQUAL(result->Status.Msg, "Permission Denied");
@@ -83,7 +83,7 @@ Y_UNIT_TEST_SUITE(TAccessServiceTest) {
         // check for found
         request = MakeHolder<NCloud::TEvAccessService::TEvAuthenticateRequest>();
         request->Request.set_iam_token("good1");
-        setup.GetRuntime()->Send(new IEventHandle(setup.AccessServiceActor->SelfId(), setup.EdgeActor, request.Release()));
+        setup.GetRuntime()->Send(new IEventHandleFat(setup.AccessServiceActor->SelfId(), setup.EdgeActor, request.Release()));
         result = setup.GetRuntime()->GrabEdgeEvent<NCloud::TEvAccessService::TEvAuthenticateResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT(result->Status.Ok());
@@ -102,7 +102,7 @@ Y_UNIT_TEST_SUITE(TAccessServiceTest) {
         auto request = MakeHolder<NCloud::TEvAccessService::TEvAuthenticateRequest>();
         request->Request.set_iam_token("token");
         request->RequestId = "trololo";
-        setup.GetRuntime()->Send(new IEventHandle(setup.AccessServiceActor->SelfId(), setup.EdgeActor, request.Release()));
+        setup.GetRuntime()->Send(new IEventHandleFat(setup.AccessServiceActor->SelfId(), setup.EdgeActor, request.Release()));
         auto result = setup.GetRuntime()->GrabEdgeEvent<NCloud::TEvAccessService::TEvAuthenticateResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT(result->Status.Ok());
diff --git a/ydb/library/ycloud/impl/folder_service_ut.cpp b/ydb/library/ycloud/impl/folder_service_ut.cpp
index a3fd4b1bde4..5081adacd7d 100644
--- a/ydb/library/ycloud/impl/folder_service_ut.cpp
+++ b/ydb/library/ycloud/impl/folder_service_ut.cpp
@@ -39,7 +39,7 @@ Y_UNIT_TEST_SUITE(TFolderServiceTest) {
         runtime->Register(folderService);
         auto request = MakeHolder<NCloud::TEvFolderService::TEvListFolderRequest>();
         request->Request.set_id("xxx");
-        runtime->Send(new IEventHandle(folderService->SelfId(), sender, request.Release()));
+        runtime->Send(new IEventHandleFat(folderService->SelfId(), sender, request.Release()));
         auto result = runtime->GrabEdgeEvent<NCloud::TEvFolderService::TEvListFolderResponse>(handle);
         UNIT_ASSERT(result); // error because no service is listening
         UNIT_ASSERT_EQUAL(result->Status.Msg, "failed to connect to all addresses");
@@ -56,7 +56,7 @@ Y_UNIT_TEST_SUITE(TFolderServiceTest) {
         auto sendEvent = [&] {
             auto request = MakeHolder<NCloud::TEvFolderService::TEvListFolderRequest>();
             request->Request.set_id(badFolderId);
-            runtime->Send(new IEventHandle(folderService->SelfId(), sender, request.Release()));
+            runtime->Send(new IEventHandleFat(folderService->SelfId(), sender, request.Release()));
             result = runtime->GrabEdgeEvent<NCloud::TEvFolderService::TEvListFolderResponse>(handle);
             return result->Status.GRpcStatusCode != 14;
         };
@@ -70,7 +70,7 @@ Y_UNIT_TEST_SUITE(TFolderServiceTest) {
         // check for found
         request = MakeHolder<NCloud::TEvFolderService::TEvListFolderRequest>();
         request->Request.set_id(goodFolderId);
-        runtime->Send(new IEventHandle(folderService->SelfId(), sender, request.Release()));
+        runtime->Send(new IEventHandleFat(folderService->SelfId(), sender, request.Release()));
         result = runtime->GrabEdgeEvent<NCloud::TEvFolderService::TEvListFolderResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT(result->Status.Ok());
diff --git a/ydb/library/ycloud/impl/grpc_service_cache.h b/ydb/library/ycloud/impl/grpc_service_cache.h
index 70eb9d5c2b3..cc4e78ec0ae 100644
--- a/ydb/library/ycloud/impl/grpc_service_cache.h
+++ b/ydb/library/ycloud/impl/grpc_service_cache.h
@@ -142,7 +142,7 @@ public:
             hFunc(TEventResponseType, Handle);
             cFunc(TEvents::TSystem::Poison, PassAway);
             default:
-                ctx.Send(ev->Forward(GetUnderlyingActor()));
+                ctx.Forward(ev, GetUnderlyingActor());
                 break;
         }
     }
diff --git a/ydb/library/ycloud/impl/service_account_service_ut.cpp b/ydb/library/ycloud/impl/service_account_service_ut.cpp
index d81ba7b446b..15cfc3e3519 100644
--- a/ydb/library/ycloud/impl/service_account_service_ut.cpp
+++ b/ydb/library/ycloud/impl/service_account_service_ut.cpp
@@ -71,13 +71,13 @@ Y_UNIT_TEST_SUITE_F(TServiceAccountServiceTest, TServiceAccountServiceFixture) {
     Y_UNIT_TEST(Get) {
         TAutoPtr<IEventHandle> handle;
         // check for not found
-        Runtime->Send(new IEventHandle(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvGetServiceAccountRequest>("bad1")));
+        Runtime->Send(new IEventHandleFat(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvGetServiceAccountRequest>("bad1")));
         auto result = Runtime->GrabEdgeEvent<NCloud::TEvServiceAccountService::TEvGetServiceAccountResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT_EQUAL(result->Status.Msg, "Not Found");
 
         // check for found
-        Runtime->Send(new IEventHandle(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvGetServiceAccountRequest>("Service1")));
+        Runtime->Send(new IEventHandleFat(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvGetServiceAccountRequest>("Service1")));
         result = Runtime->GrabEdgeEvent<NCloud::TEvServiceAccountService::TEvGetServiceAccountResponse>(handle);
 
         UNIT_ASSERT(result);
@@ -88,13 +88,13 @@ Y_UNIT_TEST_SUITE_F(TServiceAccountServiceTest, TServiceAccountServiceFixture) {
     Y_UNIT_TEST(IssueToken) {
         TAutoPtr<IEventHandle> handle;
         // check for not found
-        Runtime->Send(new IEventHandle(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvIssueTokenRequest>("bad1")));
+        Runtime->Send(new IEventHandleFat(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvIssueTokenRequest>("bad1")));
         auto result = Runtime->GrabEdgeEvent<NCloud::TEvServiceAccountService::TEvIssueTokenResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT_EQUAL(result->Status.GRpcStatusCode, grpc::StatusCode::UNAUTHENTICATED);
 
         // check for found
-        Runtime->Send(new IEventHandle(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvIssueTokenRequest>("Service1")));
+        Runtime->Send(new IEventHandleFat(ServiceAccountService->SelfId(), SenderActorId, CreateRequest<NCloud::TEvServiceAccountService::TEvIssueTokenRequest>("Service1")));
         result = Runtime->GrabEdgeEvent<NCloud::TEvServiceAccountService::TEvIssueTokenResponse>(handle);
 
         UNIT_ASSERT(result);
diff --git a/ydb/library/ycloud/impl/user_account_service_ut.cpp b/ydb/library/ycloud/impl/user_account_service_ut.cpp
index a561036c6d5..681c90f29c4 100644
--- a/ydb/library/ycloud/impl/user_account_service_ut.cpp
+++ b/ydb/library/ycloud/impl/user_account_service_ut.cpp
@@ -44,7 +44,7 @@ Y_UNIT_TEST_SUITE(TUserAccountServiceTest) {
         // check for not found
         auto request = MakeHolder<NCloud::TEvUserAccountService::TEvGetUserAccountRequest>();
         request->Request.set_user_account_id("bad1");
-        runtime->Send(new IEventHandle(userAccountService->SelfId(), sender, request.Release()));
+        runtime->Send(new IEventHandleFat(userAccountService->SelfId(), sender, request.Release()));
         auto result = runtime->GrabEdgeEvent<NCloud::TEvUserAccountService::TEvGetUserAccountResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT_EQUAL(result->Status.Msg, "Not Found");
@@ -52,7 +52,7 @@ Y_UNIT_TEST_SUITE(TUserAccountServiceTest) {
         // check for found
         request = MakeHolder<NCloud::TEvUserAccountService::TEvGetUserAccountRequest>();
         request->Request.set_user_account_id("user1");
-        runtime->Send(new IEventHandle(userAccountService->SelfId(), sender, request.Release()));
+        runtime->Send(new IEventHandleFat(userAccountService->SelfId(), sender, request.Release()));
         result = runtime->GrabEdgeEvent<NCloud::TEvUserAccountService::TEvGetUserAccountResponse>(handle);
         UNIT_ASSERT(result);
         UNIT_ASSERT(result->Status.Ok());
diff --git a/ydb/library/yql/dq/actors/compute/dq_async_compute_actor.cpp b/ydb/library/yql/dq/actors/compute/dq_async_compute_actor.cpp
index b7886cefe0f..6e8e87cf3fe 100644
--- a/ydb/library/yql/dq/actors/compute/dq_async_compute_actor.cpp
+++ b/ydb/library/yql/dq/actors/compute/dq_async_compute_actor.cpp
@@ -778,7 +778,7 @@ private:
     template <class TEvPtr>
     void ForwardToCheckpoints(TEvPtr&& ev) {
         auto* x = reinterpret_cast<TAutoPtr<NActors::IEventHandle>*>(&ev);
-        Checkpoints->Receive(*x, TActivationContext::AsActorContext());
+        Checkpoints->Receive(*x);
         ev = nullptr;
     }
 
diff --git a/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h b/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h
index 0a7f159b56f..5281bcd3b20 100644
--- a/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h
+++ b/ydb/library/yql/dq/actors/compute/dq_compute_actor_impl.h
@@ -253,13 +253,7 @@ protected:
     }
 
     TString GetEventTypeString(TAutoPtr<::NActors::IEventHandle>& ev) {
-        try {
-            if (NActors::IEventBase* eventBase = ev->GetBase()) {
-                return eventBase->ToStringHeader();
-            }
-        } catch (...) {
-        }
-        return "Unknown type";
+        return ev->GetTypeName();
     }
 
     template <auto FuncBody>
@@ -284,21 +278,21 @@ protected:
         ReportEventElapsedTime();
     }
 
-    STFUNC(BaseStateFuncBody) {
+    STATEFN(BaseStateFuncBody) {
         switch (ev->GetTypeRewrite()) {
             hFunc(TEvDqCompute::TEvResumeExecution, HandleExecuteBase);
             hFunc(TEvDqCompute::TEvChannelsInfo, HandleExecuteBase);
             hFunc(TEvDq::TEvAbortExecution, HandleExecuteBase);
             hFunc(NActors::TEvents::TEvWakeup, HandleExecuteBase);
             hFunc(NActors::TEvents::TEvUndelivered, HandleExecuteBase);
-            FFunc(TEvDqCompute::TEvChannelData::EventType, Channels->Receive);
-            FFunc(TEvDqCompute::TEvChannelDataAck::EventType, Channels->Receive);
+            fFunc(TEvDqCompute::TEvChannelData::EventType, Channels->Receive);
+            fFunc(TEvDqCompute::TEvChannelDataAck::EventType, Channels->Receive);
             hFunc(TEvDqCompute::TEvRun, HandleExecuteBase);
             hFunc(TEvDqCompute::TEvStateRequest, HandleExecuteBase);
             hFunc(TEvDqCompute::TEvNewCheckpointCoordinator, HandleExecuteBase);
-            FFunc(TEvDqCompute::TEvInjectCheckpoint::EventType, Checkpoints->Receive);
-            FFunc(TEvDqCompute::TEvCommitState::EventType, Checkpoints->Receive);
-            FFunc(TEvDqCompute::TEvRestoreFromCheckpoint::EventType, Checkpoints->Receive);
+            fFunc(TEvDqCompute::TEvInjectCheckpoint::EventType, Checkpoints->Receive);
+            fFunc(TEvDqCompute::TEvCommitState::EventType, Checkpoints->Receive);
+            fFunc(TEvDqCompute::TEvRestoreFromCheckpoint::EventType, Checkpoints->Receive);
             hFunc(NActors::TEvInterconnect::TEvNodeDisconnected, HandleExecuteBase);
             hFunc(NActors::TEvInterconnect::TEvNodeConnected, HandleExecuteBase);
             hFunc(IDqComputeActorAsyncInput::TEvNewAsyncInputDataArrived, OnNewAsyncInputDataArrived);
@@ -503,15 +497,15 @@ protected:
         }
 
         if (Channels) {
-            TAutoPtr<NActors::IEventHandle> handle = new NActors::IEventHandle(Channels->SelfId(), this->SelfId(),
+            TAutoPtr<NActors::IEventHandle> handle = new NActors::IEventHandleFat(Channels->SelfId(), this->SelfId(),
                 new NActors::TEvents::TEvPoison);
-            Channels->Receive(handle, NActors::TActivationContext::AsActorContext());
+            Channels->Receive(handle);
         }
 
         if (Checkpoints) {
-            TAutoPtr<NActors::IEventHandle> handle = new NActors::IEventHandle(Checkpoints->SelfId(), this->SelfId(),
+            TAutoPtr<NActors::IEventHandle> handle = new NActors::IEventHandleFat(Checkpoints->SelfId(), this->SelfId(),
                 new NActors::TEvents::TEvPoison);
-            Checkpoints->Receive(handle, NActors::TActivationContext::AsActorContext());
+            Checkpoints->Receive(handle);
         }
 
         {
@@ -1199,7 +1193,7 @@ protected:
         // Event from coordinator should be processed to confirm seq no.
         TAutoPtr<NActors::IEventHandle> iev(ev.Release());
         if (Checkpoints) {
-            Checkpoints->Receive(iev, NActors::TActivationContext::AsActorContext());
+            Checkpoints->Receive(iev);
         }
     }
 
@@ -1224,8 +1218,8 @@ protected:
             Checkpoints->Init(this->SelfId(), this->RegisterWithSameMailbox(Checkpoints));
             Channels->SetCheckpointsSupport();
         }
-        TAutoPtr<NActors::IEventHandle> handle = new NActors::IEventHandle(Checkpoints->SelfId(), ev->Sender, ev->Release().Release());
-        Checkpoints->Receive(handle, NActors::TActivationContext::AsActorContext());
+        TAutoPtr<NActors::IEventHandle> handle = new NActors::IEventHandleFat(Checkpoints->SelfId(), ev->Sender, ev->Release().Release());
+        Checkpoints->Receive(handle);
     }
 
     void HandleExecuteBase(TEvDq::TEvAbortExecution::TPtr& ev) {
@@ -1257,14 +1251,14 @@ protected:
     void HandleExecuteBase(NActors::TEvInterconnect::TEvNodeDisconnected::TPtr& ev) {
         TAutoPtr<NActors::IEventHandle> iev(ev.Release());
         if (Checkpoints) {
-            Checkpoints->Receive(iev, NActors::TActivationContext::AsActorContext());
+            Checkpoints->Receive(iev);
         }
     }
 
     void HandleExecuteBase(NActors::TEvInterconnect::TEvNodeConnected::TPtr& ev) {
         TAutoPtr<NActors::IEventHandle> iev(ev.Release());
         if (Checkpoints) {
-            Checkpoints->Receive(iev, NActors::TActivationContext::AsActorContext());
+            Checkpoints->Receive(iev);
         }
     }
 
diff --git a/ydb/library/yql/dq/actors/compute/retry_queue.cpp b/ydb/library/yql/dq/actors/compute/retry_queue.cpp
index e382f42017f..660f1e1bb9d 100644
--- a/ydb/library/yql/dq/actors/compute/retry_queue.cpp
+++ b/ydb/library/yql/dq/actors/compute/retry_queue.cpp
@@ -57,7 +57,7 @@ void TRetryEventsQueue::Retry() {
 void TRetryEventsQueue::Connect() {
     auto connectEvent = MakeHolder<NActors::TEvInterconnect::TEvConnectNode>();
     NActors::TActivationContext::Send(
-        new NActors::IEventHandle(NActors::TActivationContext::InterconnectProxy(RecipientId.NodeId()), SenderId, connectEvent.Release(), 0, 0));
+        new NActors::IEventHandleFat(NActors::TActivationContext::InterconnectProxy(RecipientId.NodeId()), SenderId, connectEvent.Release(), 0, 0));
 }
 
 void TRetryEventsQueue::Unsubscribe() {
@@ -65,7 +65,7 @@ void TRetryEventsQueue::Unsubscribe() {
         Connected = false;
         auto unsubscribeEvent = MakeHolder<NActors::TEvents::TEvUnsubscribe>();
         NActors::TActivationContext::Send(
-            new NActors::IEventHandle(NActors::TActivationContext::InterconnectProxy(RecipientId.NodeId()), SenderId, unsubscribeEvent.Release(), 0, 0));
+            new NActors::IEventHandleFat(NActors::TActivationContext::InterconnectProxy(RecipientId.NodeId()), SenderId, unsubscribeEvent.Release(), 0, 0));
     }
 }
 
@@ -83,7 +83,7 @@ void TRetryEventsQueue::RemoveConfirmedEvents(ui64 confirmedSeqNo) {
 }
 
 void TRetryEventsQueue::SendRetryable(const IRetryableEvent::TPtr& ev) {
-    NActors::TActivationContext::Send(ev->Clone(MyConfirmedSeqNo));
+    NActors::TActivationContext::Send(ev->Clone(MyConfirmedSeqNo).Release());
 }
 
 void TRetryEventsQueue::ScheduleRetry() {
@@ -93,7 +93,7 @@ void TRetryEventsQueue::ScheduleRetry() {
             RetryState.ConstructInPlace();
         }
         auto ev = MakeHolder<TEvRetryQueuePrivate::TEvRetry>(EventQueueId);
-        NActors::TActivationContext::Schedule(RetryState->GetNextDelay(), new NActors::IEventHandle(SelfId, SelfId, ev.Release()));
+        NActors::TActivationContext::Schedule(RetryState->GetNextDelay(), new NActors::IEventHandleFat(SelfId, SelfId, ev.Release()));
     }
 }
 
diff --git a/ydb/library/yql/dq/actors/compute/retry_queue.h b/ydb/library/yql/dq/actors/compute/retry_queue.h
index 8ec664cd5fc..0063a447db3 100644
--- a/ydb/library/yql/dq/actors/compute/retry_queue.h
+++ b/ydb/library/yql/dq/actors/compute/retry_queue.h
@@ -74,7 +74,7 @@ public:
     template <TProtobufEventWithTransportMeta T>
     void Send(THolder<T> ev, ui64 cookie = 0) {
         if (LocalRecipient) {
-            NActors::TActivationContext::Send(new NActors::IEventHandle(RecipientId, SenderId, ev.Release(), cookie));
+            NActors::TActivationContext::Send(new NActors::IEventHandleFat(RecipientId, SenderId, ev.Release(), cookie));
             return;
         }
 
@@ -87,7 +87,7 @@ public:
     }
 
     template <TProtobufEventWithTransportMeta T>
-    bool OnEventReceived(const TAutoPtr<NActors::TEventHandle<T>>& ev) {
+    bool OnEventReceived(const TAutoPtr<NActors::TEventHandleFat<T>>& ev) {
         return OnEventReceived(ev->Get());
     }
 
@@ -160,7 +160,7 @@ private:
             THolder<T> ev = MakeHolder<T>();
             ev->Record = Event->Record;
             ev->Record.MutableTransportMeta()->SetConfirmedSeqNo(confirmedSeqNo);
-            return MakeHolder<NActors::IEventHandle>(Recipient, Sender, ev.Release(), 0, Cookie);
+            return MakeHolder<NActors::IEventHandleFat>(Recipient, Sender, ev.Release(), 0, Cookie);
         }
 
     private:
diff --git a/ydb/library/yql/dq/comp_nodes/yql_common_dq_factory.cpp b/ydb/library/yql/dq/comp_nodes/yql_common_dq_factory.cpp
index 7227430c089..dd75042dd0f 100644
--- a/ydb/library/yql/dq/comp_nodes/yql_common_dq_factory.cpp
+++ b/ydb/library/yql/dq/comp_nodes/yql_common_dq_factory.cpp
@@ -21,7 +21,7 @@ public:
 
     private:
         NUdf::TUnboxedValue Run(const NUdf::IValueBuilder*, const NUdf::TUnboxedValuePod*) const override {
-            ActorSystem->Send(new NActors::IEventHandle(
+            ActorSystem->Send(new NActors::IEventHandleFat(
                 CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
             return NUdf::TUnboxedValue::Void();
         }
diff --git a/ydb/library/yql/providers/clickhouse/actors/yql_ch_read_actor.cpp b/ydb/library/yql/providers/clickhouse/actors/yql_ch_read_actor.cpp
index 5b565569624..670c1bf6d95 100644
--- a/ydb/library/yql/providers/clickhouse/actors/yql_ch_read_actor.cpp
+++ b/ydb/library/yql/providers/clickhouse/actors/yql_ch_read_actor.cpp
@@ -82,10 +82,10 @@ private:
     static void OnDownloadFinished(TActorSystem* actorSystem, TActorId selfId, IHTTPGateway::TResult&& result) {
         switch (result.index()) {
         case 0U:
-            actorSystem->Send(new IEventHandle(selfId, TActorId(), new TEvPrivate::TEvReadResult(std::get<IHTTPGateway::TContent>(std::move(result)))));
+            actorSystem->Send(new IEventHandleFat(selfId, TActorId(), new TEvPrivate::TEvReadResult(std::get<IHTTPGateway::TContent>(std::move(result)))));
             return;
         case 1U:
-            actorSystem->Send(new IEventHandle(selfId, TActorId(), new TEvPrivate::TEvReadError(std::get<TIssues>(std::move(result)))));
+            actorSystem->Send(new IEventHandleFat(selfId, TActorId(), new TEvPrivate::TEvReadError(std::get<TIssues>(std::move(result)))));
             return;
         default:
             break;
diff --git a/ydb/library/yql/providers/common/ut_helpers/dq_fake_ca.cpp b/ydb/library/yql/providers/common/ut_helpers/dq_fake_ca.cpp
index 402e9e73115..2529cc77b05 100644
--- a/ydb/library/yql/providers/common/ut_helpers/dq_fake_ca.cpp
+++ b/ydb/library/yql/providers/common/ut_helpers/dq_fake_ca.cpp
@@ -139,7 +139,7 @@ void TFakeCASetup::Execute(TCallback callback) {
     std::exception_ptr exception_ptr = nullptr;
     const TActorId& edgeId = Runtime->AllocateEdgeActor();
     auto promise = NThreading::NewPromise();
-    Runtime->Send(new IEventHandle(FakeActorId, edgeId, new TEvPrivate::TEvExecute(promise, callback, exception_ptr)));
+    Runtime->Send(new IEventHandleFat(FakeActorId, edgeId, new TEvPrivate::TEvExecute(promise, callback, exception_ptr)));
     auto future = promise.GetFuture();
     future.Wait();
     if (exception_ptr) {
diff --git a/ydb/library/yql/providers/dq/actors/actor_helpers.h b/ydb/library/yql/providers/dq/actors/actor_helpers.h
index cf66de3ea40..228377cf795 100644
--- a/ydb/library/yql/providers/dq/actors/actor_helpers.h
+++ b/ydb/library/yql/providers/dq/actors/actor_helpers.h
@@ -19,7 +19,7 @@ enum EExecutorPoolType {
 
 template <typename EventType>
 struct TRichActorFutureCallback : public TRichActor<TRichActorFutureCallback<EventType>> {
-    using TCallback = std::function<void(TAutoPtr<NActors::TEventHandle<EventType>>&)>;
+    using TCallback = std::function<void(TAutoPtr<NActors::TEventHandleFat<EventType>>&)>;
     using TFailure = std::function<void(void)>;
     using TBase = TRichActor<TRichActorFutureCallback<EventType>>;
 
@@ -64,7 +64,7 @@ private:
     }
 
     TAutoPtr<NActors::IEventHandle> AfterRegister(const NActors::TActorId& self, const NActors::TActorId& parentId) override {
-        return new NActors::IEventHandle(self, parentId, new NActors::TEvents::TEvBootstrap, 0);
+        return new NActors::IEventHandleFat(self, parentId, new NActors::TEvents::TEvBootstrap, 0);
     }
 
     void OnFailure() {
diff --git a/ydb/library/yql/providers/dq/actors/executer_actor.cpp b/ydb/library/yql/providers/dq/actors/executer_actor.cpp
index 32a3c897de8..3b99d6f571a 100644
--- a/ydb/library/yql/providers/dq/actors/executer_actor.cpp
+++ b/ydb/library/yql/providers/dq/actors/executer_actor.cpp
@@ -224,7 +224,7 @@ private:
 
         StartCounter("AllocateWorkers");
 
-        TActivationContext::Send(new IEventHandle(
+        TActivationContext::Send(new IEventHandleFat(
             GwmActorId,
             resourceAllocator,
             allocateRequest.Release(),
@@ -414,7 +414,7 @@ private:
     }
 
     TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override {
-        return new IEventHandle(self, parentId, new TEvents::TEvWakeup(), 0);
+        return new IEventHandleFat(self, parentId, new TEvents::TEvWakeup(), 0);
     }
 
     void OnWakeup() {
diff --git a/ydb/library/yql/providers/dq/actors/resource_allocator.cpp b/ydb/library/yql/providers/dq/actors/resource_allocator.cpp
index e9a2bdd518e..17e43ad1fc4 100644
--- a/ydb/library/yql/providers/dq/actors/resource_allocator.cpp
+++ b/ydb/library/yql/providers/dq/actors/resource_allocator.cpp
@@ -255,7 +255,7 @@ private:
         }
         YQL_CLOG(WARN, ProviderDq) << "Send TEvAllocateWorkersRequest to " << NDqs::NExecutionHelpers::PrettyPrintWorkerInfo(node.WorkerInfo, 0);
         if (backoff) {
-            TActivationContext::Schedule(backoff, new IEventHandle(
+            TActivationContext::Schedule(backoff, new IEventHandleFat(
                 MakeWorkerManagerActorID(nodeId), SelfId(), request.Release(),
                 IEventHandle::FlagTrackDelivery | IEventHandle::FlagGenerateUnsureUndelivered,
                 node.ResourceId));
diff --git a/ydb/library/yql/providers/dq/actors/worker_actor.cpp b/ydb/library/yql/providers/dq/actors/worker_actor.cpp
index b329f3e3474..e6d250ac6e8 100644
--- a/ydb/library/yql/providers/dq/actors/worker_actor.cpp
+++ b/ydb/library/yql/providers/dq/actors/worker_actor.cpp
@@ -485,7 +485,7 @@ private:
             SendFailure(MakeHolder<TEvDqFailure>(NYql::NDqProto::StatusIds::UNAVAILABLE, message));
         } else if (ev->Get()->SourceType == TEvPullDataRequest::EventType) {
             TActivationContext::Schedule(TDuration::MilliSeconds(100),
-                new IEventHandle(maybeChannel->second.ActorID, SelfId(), new TEvPullDataRequest(INPUT_SIZE), IEventHandle::FlagTrackDelivery)
+                new IEventHandleFat(maybeChannel->second.ActorID, SelfId(), new TEvPullDataRequest(INPUT_SIZE), IEventHandle::FlagTrackDelivery)
             );
             maybeChannel->second.Retries ++;
             maybeChannel->second.Requested = true;
@@ -493,7 +493,7 @@ private:
         } else {
             // Ping
             TActivationContext::Schedule(TDuration::MilliSeconds(100),
-                new IEventHandle(maybeChannel->second.ActorID, SelfId(), new TEvPingRequest(), IEventHandle::FlagTrackDelivery)
+                new IEventHandleFat(maybeChannel->second.ActorID, SelfId(), new TEvPingRequest(), IEventHandle::FlagTrackDelivery)
             );
             maybeChannel->second.PingRequested = true;
         }
diff --git a/ydb/library/yql/providers/dq/task_runner_actor/task_runner_actor.cpp b/ydb/library/yql/providers/dq/task_runner_actor/task_runner_actor.cpp
index e77eb6b8962..63796689f11 100644
--- a/ydb/library/yql/providers/dq/task_runner_actor/task_runner_actor.cpp
+++ b/ydb/library/yql/providers/dq/task_runner_actor/task_runner_actor.cpp
@@ -219,7 +219,7 @@ private:
 
                 // run
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         new TEvPushFinished(channelId, freeSpace),
@@ -228,7 +228,7 @@ private:
             } catch (...) {
                 auto status = taskRunner->GetStatus();
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(),
@@ -264,7 +264,7 @@ private:
                     source->Finish();
                 }
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         parentId,
                         selfId,
                         new TEvAsyncInputPushFinished(index, source->GetFreeSpace()),
@@ -273,7 +273,7 @@ private:
             } catch (...) {
                 auto status = taskRunner->GetStatus();
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         parentId,
                         selfId,
                         MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(),
@@ -329,7 +329,7 @@ private:
                 }
 
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         new TEvChannelPopFinished(
@@ -345,7 +345,7 @@ private:
             } catch (...) {
                 auto status = taskRunner->GetStatus();
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(),
@@ -403,7 +403,7 @@ private:
                 event->Strings = std::move(batch);
                 // repack data and forward
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         selfId,
                         replyTo,
                         event.Release(),
@@ -412,7 +412,7 @@ private:
             } catch (...) {
                 auto status = taskRunner->GetStatus();
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(),
@@ -478,7 +478,7 @@ private:
                     sensors);
 
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         event.Release(),
@@ -487,7 +487,7 @@ private:
             } catch (...) {
                 auto status = taskRunner->GetStatus();
                 actorSystem->Send(
-                    new IEventHandle(replyTo, selfId, MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(), 0, cookie));
+                    new IEventHandleFat(replyTo, selfId, MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(), 0, cookie));
             }
         });
     }
@@ -523,7 +523,7 @@ private:
                 }
 
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         new TEvTaskRunFinished(
@@ -544,7 +544,7 @@ private:
             } catch (...) {
                 auto status = taskRunner->GetStatus();
                 actorSystem->Send(
-                    new IEventHandle(
+                    new IEventHandleFat(
                         replyTo,
                         selfId,
                         MakeError({status.ExitCode, status.Stderr}, settings, stageId).Release(),
diff --git a/ydb/library/yql/providers/dq/worker_manager/local_worker_manager.cpp b/ydb/library/yql/providers/dq/worker_manager/local_worker_manager.cpp
index 7da4c641583..e37f0d25590 100644
--- a/ydb/library/yql/providers/dq/worker_manager/local_worker_manager.cpp
+++ b/ydb/library/yql/providers/dq/worker_manager/local_worker_manager.cpp
@@ -82,7 +82,7 @@ private:
     })
 
     TAutoPtr<IEventHandle> AfterRegister(const TActorId& self, const TActorId& parentId) override {
-        return new IEventHandle(self, parentId, new TEvents::TEvBootstrap(), 0);
+        return new IEventHandleFat(self, parentId, new TEvents::TEvBootstrap(), 0);
     }
 
     void Bootstrap() {
@@ -105,7 +105,7 @@ private:
 
         FreeOnDeadline();
 
-        TActivationContext::Schedule(TDuration::MilliSeconds(800), new IEventHandle(SelfId(), SelfId(), new TEvents::TEvWakeup(), 0));
+        TActivationContext::Schedule(TDuration::MilliSeconds(800), new IEventHandleFat(SelfId(), SelfId(), new TEvents::TEvWakeup(), 0));
     }
 
     void DoPassAway() override {
diff --git a/ydb/library/yql/providers/dq/worker_manager/worker_manager_common.h b/ydb/library/yql/providers/dq/worker_manager/worker_manager_common.h
index 6c04adec72a..67489a3e2f1 100644
--- a/ydb/library/yql/providers/dq/worker_manager/worker_manager_common.h
+++ b/ydb/library/yql/providers/dq/worker_manager/worker_manager_common.h
@@ -22,7 +22,7 @@ public:
         auto* actorSystem = ctx.ExecutorThread.ActorSystem;
 
         auto callback = MakeHolder<NActors::TActorFutureCallback<NActors::TEvInterconnect::TEvNodesInfo>>(
-            [replyTo, actorSystem] (TAutoPtr<NActors::TEventHandle<NActors::TEvInterconnect::TEvNodesInfo>>& event) {
+            [replyTo, actorSystem] (TAutoPtr<NActors::TEventHandleFat<NActors::TEvInterconnect::TEvNodesInfo>>& event) {
                 auto response = MakeHolder<TEvRoutesResponse>();
                 for (const auto& node: event->Get()->Nodes) {
                     auto* n = response->Record.MutableResponse()->AddNodes();
@@ -37,7 +37,7 @@ public:
 
         auto callbackId = ctx.Register(callback.Release());
 
-        ctx.Send(new NActors::IEventHandle(NActors::GetNameserviceActorId(), callbackId, localRequest.Release()));
+        ctx.Send(new NActors::IEventHandleFat(NActors::GetNameserviceActorId(), callbackId, localRequest.Release()));
     }
 };
 
diff --git a/ydb/library/yql/providers/s3/actors/yql_s3_read_actor.cpp b/ydb/library/yql/providers/s3/actors/yql_s3_read_actor.cpp
index 68eea4ad522..2bdbaaa2756 100644
--- a/ydb/library/yql/providers/s3/actors/yql_s3_read_actor.cpp
+++ b/ydb/library/yql/providers/s3/actors/yql_s3_read_actor.cpp
@@ -242,7 +242,7 @@ struct TEvPrivate {
     };
 
     struct TEvNextBlock : public NActors::TEventLocal<TEvNextBlock, EvNextBlock> {
-        TEvNextBlock(NDB::Block& block, size_t pathInd, std::function<void()> functor, ui64 ingressDelta, TDuration cpuTimeDelta) 
+        TEvNextBlock(NDB::Block& block, size_t pathInd, std::function<void()> functor, ui64 ingressDelta, TDuration cpuTimeDelta)
             : PathIndex(pathInd), Functor(functor), IngressDelta(ingressDelta), CpuTimeDelta(cpuTimeDelta) {
             Block.swap(block);
         }
@@ -255,7 +255,7 @@ struct TEvPrivate {
 
     struct TEvNextRecordBatch : public NActors::TEventLocal<TEvNextRecordBatch, EvNextRecordBatch> {
         TEvNextRecordBatch(const std::shared_ptr<arrow::RecordBatch>& batch, size_t pathInd, std::function<void()> functor, ui64 ingressDelta, TDuration cpuTimeDelta)
-            : Batch(batch), PathIndex(pathInd), Functor(functor), IngressDelta(ingressDelta), CpuTimeDelta(cpuTimeDelta) { 
+            : Batch(batch), PathIndex(pathInd), Functor(functor), IngressDelta(ingressDelta), CpuTimeDelta(cpuTimeDelta) {
         }
         std::shared_ptr<arrow::RecordBatch> Batch;
         const size_t PathIndex;
@@ -836,10 +836,10 @@ private:
     static void OnDownloadFinished(TActorSystem* actorSystem, TActorId selfId, const TString& requestId, IHTTPGateway::TResult&& result, size_t pathInd, const TString path) {
         switch (result.index()) {
         case 0U:
-            actorSystem->Send(new IEventHandle(selfId, TActorId(), new TEvPrivate::TEvReadResult(std::get<IHTTPGateway::TContent>(std::move(result)), requestId, pathInd, path)));
+            actorSystem->Send(new IEventHandleFat(selfId, TActorId(), new TEvPrivate::TEvReadResult(std::get<IHTTPGateway::TContent>(std::move(result)), requestId, pathInd, path)));
             return;
         case 1U:
-            actorSystem->Send(new IEventHandle(selfId, TActorId(), new TEvPrivate::TEvReadError(std::get<TIssues>(std::move(result)), requestId, pathInd, path)));
+            actorSystem->Send(new IEventHandleFat(selfId, TActorId(), new TEvPrivate::TEvReadError(std::get<TIssues>(std::move(result)), requestId, pathInd, path)));
             return;
         default:
             break;
@@ -1080,15 +1080,15 @@ struct TRetryStuff {
 };
 
 void OnDownloadStart(TActorSystem* actorSystem, const TActorId& self, const TActorId& parent, long httpResponseCode) {
-    actorSystem->Send(new IEventHandle(self, parent, new TEvPrivate::TEvReadStarted(httpResponseCode)));
+    actorSystem->Send(new IEventHandleFat(self, parent, new TEvPrivate::TEvReadStarted(httpResponseCode)));
 }
 
 void OnNewData(TActorSystem* actorSystem, const TActorId& self, const TActorId& parent, IHTTPGateway::TCountedContent&& data) {
-    actorSystem->Send(new IEventHandle(self, parent, new TEvPrivate::TEvDataPart(std::move(data))));
+    actorSystem->Send(new IEventHandleFat(self, parent, new TEvPrivate::TEvDataPart(std::move(data))));
 }
 
 void OnDownloadFinished(TActorSystem* actorSystem, const TActorId& self, const TActorId& parent, size_t pathIndex, TIssues issues) {
-    actorSystem->Send(new IEventHandle(self, parent, new TEvPrivate::TEvReadFinished(pathIndex, std::move(issues))));
+    actorSystem->Send(new IEventHandleFat(self, parent, new TEvPrivate::TEvReadFinished(pathIndex, std::move(issues))));
 }
 
 void DownloadStart(const TRetryStuff::TPtr& retryStuff, TActorSystem* actorSystem, const TActorId& self, const TActorId& parent, size_t pathIndex, const ::NMonitoring::TDynamicCounters::TCounterPtr& inflightCounter) {
@@ -1245,7 +1245,7 @@ public:
             return result;
         }
         arrow::Status WillNeed(const std::vector<arrow::io::ReadRange>& ranges) override {
-            return Impl->WillNeed(ranges); 
+            return Impl->WillNeed(ranges);
         }
 
     private:
@@ -1341,7 +1341,7 @@ public:
                 --cntBlocksInFly;
             }
             Send(ParentActorId, new TEvPrivate::TEvNextBlock(batch, PathIndex, [actorSystem, selfId]() {
-                actorSystem->Send(new IEventHandle(selfId, TActorId{}, new TEvPrivate::TEvBlockProcessed()));
+                actorSystem->Send(new IEventHandleFat(selfId, TActorId{}, new TEvPrivate::TEvBlockProcessed()));
             }, TakeIngressDelta(), TakeCpuTimeDelta()));
         }
         while (cntBlocksInFly--) {
@@ -1382,7 +1382,7 @@ public:
 
         auto future = ArrowReader->GetSchema(fileDesc);
         future.Subscribe([actorSystem, selfId](const NThreading::TFuture<IArrowReader::TSchemaResponse>&) {
-            actorSystem->Send(new IEventHandle(selfId, selfId, new TEvPrivate::TEvFutureResolved()));
+            actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvPrivate::TEvFutureResolved()));
         });
 
         CpuTime += GetCpuTimeDelta();
@@ -1404,7 +1404,7 @@ public:
 
             auto future = ArrowReader->ReadRowGroup(fileDesc, group, columnIndices);
             future.Subscribe([actorSystem, selfId](const NThreading::TFuture<std::shared_ptr<arrow::Table>>&){
-                actorSystem->Send(new IEventHandle(selfId, selfId, new TEvPrivate::TEvFutureResolved()));
+                actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvPrivate::TEvFutureResolved()));
             });
 
             CpuTime += GetCpuTimeDelta();
@@ -1452,10 +1452,10 @@ public:
     static void OnResult(TActorSystem* actorSystem, TActorId selfId, TEvPrivate::TReadRange range, ui64 cookie, IHTTPGateway::TResult&& result) {
         switch (result.index()) {
         case 0U:
-            actorSystem->Send(new IEventHandle(selfId, TActorId{}, new TEvPrivate::TEvReadResult2(range, std::get<IHTTPGateway::TContent>(std::move(result))), 0, cookie));
+            actorSystem->Send(new IEventHandleFat(selfId, TActorId{}, new TEvPrivate::TEvReadResult2(range, std::get<IHTTPGateway::TContent>(std::move(result))), 0, cookie));
             return;
         case 1U:
-            actorSystem->Send(new IEventHandle(selfId, TActorId{}, new TEvPrivate::TEvReadResult2(range, std::get<TIssues>(std::move(result))), 0, cookie));
+            actorSystem->Send(new IEventHandleFat(selfId, TActorId{}, new TEvPrivate::TEvReadResult2(range, std::get<TIssues>(std::move(result))), 0, cookie));
             return;
         default:
             break;
@@ -1640,8 +1640,8 @@ public:
 
         LOG_CORO_D("RunCoroBlockArrowParserOverFile");
 
-        std::shared_ptr<arrow::io::RandomAccessFile> arrowFile = 
-            std::make_shared<TRandomAccessFileTrafficCounter>(this, 
+        std::shared_ptr<arrow::io::RandomAccessFile> arrowFile =
+            std::make_shared<TRandomAccessFileTrafficCounter>(this,
                 arrow::io::ReadableFile::Open((Url + Path).substr(7), arrow::default_memory_pool()).ValueOrDie()
             );
         std::unique_ptr<parquet::arrow::FileReader> fileReader;
@@ -1680,7 +1680,7 @@ public:
                 }
                 Send(ParentActorId, new TEvPrivate::TEvNextRecordBatch(
                     ConvertArrowColumns(batch, columnConverters), PathIndex, [actorSystem, selfId]() {
-                        actorSystem->Send(new IEventHandle(selfId, TActorId{}, new TEvPrivate::TEvBlockProcessed()));
+                        actorSystem->Send(new IEventHandleFat(selfId, TActorId{}, new TEvPrivate::TEvBlockProcessed()));
                     }, TakeIngressDelta(), TakeCpuTimeDelta()
                 ));
             }
@@ -1790,7 +1790,7 @@ public:
         }
 
         if (!RetryStuff->IsCancelled() && RetryStuff->NextRetryDelay && RetryStuff->SizeLimit > 0ULL) {
-            GetActorSystem()->Schedule(*RetryStuff->NextRetryDelay, new IEventHandle(ParentActorId, SelfActorId, new TEvPrivate::TEvRetryEventFunc(std::bind(&DownloadStart, RetryStuff, GetActorSystem(), SelfActorId, ParentActorId, PathIndex, HttpInflightSize))));
+            GetActorSystem()->Schedule(*RetryStuff->NextRetryDelay, new IEventHandleFat(ParentActorId, SelfActorId, new TEvPrivate::TEvRetryEventFunc(std::bind(&DownloadStart, RetryStuff, GetActorSystem(), SelfActorId, ParentActorId, PathIndex, HttpInflightSize))));
             InputBuffer.clear();
             if (DeferredDataParts.size()) {
                 if (DeferredQueueSize) {
@@ -1890,7 +1890,7 @@ private:
                 if (ReadSpec->Compression) {
                     Issues.AddIssue(TIssue("Blocks optimisations are incompatible with external compression, use Pragma DisableUseBlocks"));
                     fatalCode = NYql::NDqProto::StatusIds::BAD_REQUEST;
-                } else {                
+                } else {
                     try {
                         if (ReadSpec->ThreadPool) {
                             RunThreadPoolBlockArrowParser();
@@ -1908,7 +1908,7 @@ private:
                     }
                 }
             } else {
-                try {            
+                try {
                     if (Url.StartsWith("file://")) {
                         RunClickHouseParserOverFile();
                     } else {
diff --git a/ydb/library/yql/providers/s3/actors/yql_s3_write_actor.cpp b/ydb/library/yql/providers/s3/actors/yql_s3_write_actor.cpp
index 038bf59ab31..ec5740cda40 100644
--- a/ydb/library/yql/providers/s3/actors/yql_s3_write_actor.cpp
+++ b/ydb/library/yql/providers/s3/actors/yql_s3_write_actor.cpp
@@ -225,25 +225,25 @@ private:
             TS3Result s3Result(std::get<IHTTPGateway::TContent>(std::move(result)).Extract());
             const auto& root = s3Result.GetRootNode();
             if (s3Result.IsError) {
-                actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(s3Result.S3ErrorCode, TStringBuilder{} << s3Result.ErrorMessage << ", request id: [" << requestId << "]")));
+                actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(s3Result.S3ErrorCode, TStringBuilder{} << s3Result.ErrorMessage << ", request id: [" << requestId << "]")));
             } else if (root.Name() != "InitiateMultipartUploadResult")
-                actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected response on create upload: " << root.Name() << ", request id: [" << requestId << "]")));
+                actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected response on create upload: " << root.Name() << ", request id: [" << requestId << "]")));
             else {
                 const NXml::TNamespacesForXPath nss(1U, {"s3", "http://s3.amazonaws.com/doc/2006-03-01/"});
-                actorSystem->Send(new IEventHandle(selfId, selfId, new TEvPrivate::TEvUploadStarted(root.Node("s3:UploadId", false, nss).Value<TString>())));
+                actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvPrivate::TEvUploadStarted(root.Node("s3:UploadId", false, nss).Value<TString>())));
             }
             break;
         } catch (const std::exception& ex) {
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Error on parse create upload response: " << ex.what()  << ", request id: [" << requestId << "]")));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Error on parse create upload response: " << ex.what()  << ", request id: [" << requestId << "]")));
             break;
         }
         case 1U: {
             auto issues = NS3Util::AddParentIssue(TStringBuilder{} << "Upload error, request id: [" << requestId << "], ", std::get<TIssues>(std::move(result)));
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
             break;
         }
         default:
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected variant index " << result.index() << " on create upload response." << ", request id: [" << requestId << "]")));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected variant index " << result.index() << " on create upload response." << ", request id: [" << requestId << "]")));
             break;
         }
     }
@@ -253,14 +253,14 @@ private:
         case 0U: {
             const auto& str = std::get<IHTTPGateway::TContent>(response).Headers;
             if (const NHttp::THeaders headers(str.substr(str.rfind("HTTP/"))); headers.Has("Etag"))
-                actorSystem->Send(new IEventHandle(selfId, selfId, new TEvPrivate::TEvUploadPartFinished(size, index, TString(headers.Get("Etag")))));
+                actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvPrivate::TEvUploadPartFinished(size, index, TString(headers.Get("Etag")))));
             else {
                 TS3Result s3Result(std::get<IHTTPGateway::TContent>(std::move(response)).Extract());
                 if (s3Result.IsError && s3Result.Parsed) {
-                    actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(s3Result.S3ErrorCode, TStringBuilder{} << "Upload failed: " << s3Result.ErrorMessage << ", request id: [" << requestId << "]")));
+                    actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(s3Result.S3ErrorCode, TStringBuilder{} << "Upload failed: " << s3Result.ErrorMessage << ", request id: [" << requestId << "]")));
                 } else {
                     constexpr size_t BODY_MAX_SIZE = 1_KB;
-                    actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR,
+                    actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR,
                         TStringBuilder() << "Unexpected response"
                             << ". Headers: " << str
                             << ". Body: \"" << TStringBuf(s3Result.Body).Trunc(BODY_MAX_SIZE)
@@ -272,7 +272,7 @@ private:
             break;
         case 1U: {
             auto issues = NS3Util::AddParentIssue(TStringBuilder{} << "PartUpload error, request id: [" << requestId << "], ", std::get<TIssues>(std::move(response)));
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
             break;
         }
         }
@@ -284,23 +284,23 @@ private:
             TS3Result s3Result(std::get<IHTTPGateway::TContent>(std::move(result)).Extract());
             const auto& root = s3Result.GetRootNode();
             if (s3Result.IsError) {
-                actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(s3Result.S3ErrorCode, TStringBuilder{} << s3Result.ErrorMessage << ", request id: [" << requestId << "]")));
+                actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(s3Result.S3ErrorCode, TStringBuilder{} << s3Result.ErrorMessage << ", request id: [" << requestId << "]")));
             } else if (root.Name() != "CompleteMultipartUploadResult")
-                actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected response on finish upload: " << root.Name() << ", request id: [" << requestId << "]")));
+                actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected response on finish upload: " << root.Name() << ", request id: [" << requestId << "]")));
             else
-                actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadFinished(key, url, sentSize)));
+                actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadFinished(key, url, sentSize)));
             break;
         } catch (const std::exception& ex) {
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Error on parse finish upload response: " << ex.what() << ", request id: [" << requestId << "]")));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Error on parse finish upload response: " << ex.what() << ", request id: [" << requestId << "]")));
             break;
         }
         case 1U: {
             auto issues = NS3Util::AddParentIssue(TStringBuilder{} << "Multipart error, request id: [" << requestId << "], ", std::get<TIssues>(std::move(result)));
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
             break;
         }
         default:
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected variant index " << result.index() << " on finish upload response." << ", request id: [" << requestId << "]")));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected variant index " << result.index() << " on finish upload response." << ", request id: [" << requestId << "]")));
             break;
         }
     }
@@ -313,22 +313,22 @@ private:
                 TString errorCode;
                 TString message;
                 if (ParseS3ErrorResponse(errorText, errorCode, message)) {
-                    actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(content.HttpResponseCode, errorCode, TStringBuilder{} << message << ", request id: [" << requestId << "]")));
+                    actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(content.HttpResponseCode, errorCode, TStringBuilder{} << message << ", request id: [" << requestId << "]")));
                 } else {
-                    actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(content.HttpResponseCode, TStringBuilder{} << errorText << ", request id: [" << requestId << "]")));
+                    actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(content.HttpResponseCode, TStringBuilder{} << errorText << ", request id: [" << requestId << "]")));
                 }
             } else {
-                actorSystem->Send(new IEventHandle(selfId, selfId, new TEvPrivate::TEvUploadFinished(key, url, sentSize)));
-                actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadFinished(key, url, sentSize)));
+                actorSystem->Send(new IEventHandleFat(selfId, selfId, new TEvPrivate::TEvUploadFinished(key, url, sentSize)));
+                actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadFinished(key, url, sentSize)));
             }
             break;
         case 1U: {
             auto issues = NS3Util::AddParentIssue(TStringBuilder{} << "UploadFinish error, request id: [" << requestId << "], ", std::get<TIssues>(std::move(result)));
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(std::move(issues))));
             break;
         }
         default:
-            actorSystem->Send(new IEventHandle(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected variant index " << result.index() << " on finish upload response." << ", request id: [" << requestId << "]")));
+            actorSystem->Send(new IEventHandleFat(parentId, selfId, new TEvPrivate::TEvUploadError(NYql::NDqProto::StatusIds::INTERNAL_ERROR, TStringBuilder() << "Unexpected variant index " << result.index() << " on finish upload response." << ", request id: [" << requestId << "]")));
             break;
         }
     }
diff --git a/ydb/library/yql/providers/ydb/actors/yql_ydb_read_actor.cpp b/ydb/library/yql/providers/ydb/actors/yql_ydb_read_actor.cpp
index 48c4bebd2f9..98d6c234d96 100644
--- a/ydb/library/yql/providers/ydb/actors/yql_ydb_read_actor.cpp
+++ b/ydb/library/yql/providers/ydb/actors/yql_ydb_read_actor.cpp
@@ -156,7 +156,7 @@ private:
     }
 
     static void OnRespond(TActorSystem* ass, const TActorId& selfId, const ::NYdb::NClickhouseInternal::TAsyncScanResult& result) {
-        ass->Send(new IEventHandle(selfId, TActorId(), new TEvPrivate::TEvScanResult(const_cast<::NYdb::NClickhouseInternal::TAsyncScanResult&>(result).ExtractValueSync())));
+        ass->Send(new IEventHandleFat(selfId, TActorId(), new TEvPrivate::TEvScanResult(const_cast<::NYdb::NClickhouseInternal::TAsyncScanResult&>(result).ExtractValueSync())));
     }
 
     void Handle(TEvPrivate::TEvScanResult::TPtr& result) {
@@ -195,7 +195,7 @@ private:
             Send(ComputeActorId, new TEvAsyncInputError(InputIndex, res.GetIssues(), NYql::NDqProto::StatusIds::EXTERNAL_ERROR));
         } else {
             WakeUpTime = TMonotonic::Now() + Min(TDuration::Seconds(3), TDuration::MilliSeconds(0x30U * (1U << ++Retried)));
-            ActorSystem->Schedule(WakeUpTime, new IEventHandle(SelfId(), TActorId(), new TEvPrivate::TEvRetryTime));
+            ActorSystem->Schedule(WakeUpTime, new IEventHandleFat(SelfId(), TActorId(), new TEvPrivate::TEvRetryTime));
         }
     }
 
diff --git a/ydb/library/yql/providers/ydb/comp_nodes/yql_kik_scan.cpp b/ydb/library/yql/providers/ydb/comp_nodes/yql_kik_scan.cpp
index 074901f74fa..7640449186a 100644
--- a/ydb/library/yql/providers/ydb/comp_nodes/yql_kik_scan.cpp
+++ b/ydb/library/yql/providers/ydb/comp_nodes/yql_kik_scan.cpp
@@ -136,12 +136,12 @@ using TBaseComputation = TMutableComputationNode<TKikScan<Async>>;
             void OnRespond(const NYdb::NClickhouseInternal::TAsyncScanResult& result) {
                 if (const auto& res = result.GetValueSync(); res.GetStatus() == NYdb::EStatus::SUCCESS) {
                     ProcessResult(res);
-                    ActorSystem->Send(new NActors::IEventHandle(CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
+                    ActorSystem->Send(new NActors::IEventHandleFat(CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
                 } else if (!IsRetriable(res.GetStatus()) || Retried > MaxRetries) {
                     ProcessError(res);
-                    ActorSystem->Send(new NActors::IEventHandle(CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
+                    ActorSystem->Send(new NActors::IEventHandleFat(CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
                 } else {
-                    ActorSystem->Schedule(ProcessRetry(), new NActors::IEventHandle(CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
+                    ActorSystem->Schedule(ProcessRetry(), new NActors::IEventHandleFat(CurrentActorId, NActors::TActorId(), new NDq::TEvDqCompute::TEvResumeExecution()));
                 }
             }
 
diff --git a/ydb/library/yql/utils/actors/http_sender_actor_ut.cpp b/ydb/library/yql/utils/actors/http_sender_actor_ut.cpp
index 883bdc01f91..6d70409e17f 100644
--- a/ydb/library/yql/utils/actors/http_sender_actor_ut.cpp
+++ b/ydb/library/yql/utils/actors/http_sender_actor_ut.cpp
@@ -51,7 +51,7 @@ struct TTestBootstrap {
         auto sender = Runtime->AllocateEdgeActor();
         auto req = NHttp::THttpOutgoingRequest::CreateRequestGet("124");
         auto request = std::make_unique<NHttp::TEvHttpProxy::TEvHttpOutgoingRequest>(req);
-        Runtime->Send(new IEventHandle(HttpSenderActorId, sender, request.release()));
+        Runtime->Send(new IEventHandleFat(HttpSenderActorId, sender, request.release()));
     }
 
     template<typename T>
@@ -68,7 +68,7 @@ struct TTestBootstrap {
 
         NHttp::THttpOutgoingRequestPtr request = nullptr; //new NHttp::THttpOutgoingRequest();
 
-        Runtime->Send(new IEventHandle(
+        Runtime->Send(new IEventHandleFat(
             HttpSenderActorId,
             HttpProxyActorId,
             new NHttp::TEvHttpProxy::TEvHttpIncomingResponse(event->Request, response.release())));
diff --git a/ydb/services/bg_tasks/ut/ut_tasks.cpp b/ydb/services/bg_tasks/ut/ut_tasks.cpp
index 2d01f1490f9..f6afb33e5ee 100644
--- a/ydb/services/bg_tasks/ut/ut_tasks.cpp
+++ b/ydb/services/bg_tasks/ut/ut_tasks.cpp
@@ -52,7 +52,7 @@ Y_UNIT_TEST_SUITE(BGTaskTests) {
             activityId = tActivity->GetActivityTaskId();
             std::shared_ptr<TTestInsertTaskScheduler> tScheduler(new TTestInsertTaskScheduler);
             NBackgroundTasks::TTask newTask(tActivity, tScheduler);
-            runtime.SendAsync(new IEventHandle(NBackgroundTasks::MakeServiceId(1), {}, new NBackgroundTasks::TEvAddTask(std::move(newTask))));
+            runtime.SendAsync(new IEventHandleFat(NBackgroundTasks::MakeServiceId(1), {}, new NBackgroundTasks::TEvAddTask(std::move(newTask))));
         }
         TDispatchOptions rmReady;
         rmReady.CustomFinalCondition = [activityId] {
@@ -114,7 +114,7 @@ Y_UNIT_TEST_SUITE(BGTaskTests) {
                 activityId = tActivity->GetActivityTaskId();
                 std::shared_ptr<TTestInsertTaskScheduler> tScheduler(new TTestInsertTaskScheduler);
                 NBackgroundTasks::TTask newTask(tActivity, tScheduler);
-                runtime.SendAsync(new IEventHandle(NBackgroundTasks::MakeServiceId(1), {}, new NBackgroundTasks::TEvAddTask(std::move(newTask))));
+                runtime.SendAsync(new IEventHandleFat(NBackgroundTasks::MakeServiceId(1), {}, new NBackgroundTasks::TEvAddTask(std::move(newTask))));
             }
             TDispatchOptions rmReady;
             rmReady.CustomFinalCondition = [activityId] {
diff --git a/ydb/services/lib/actors/pq_schema_actor.h b/ydb/services/lib/actors/pq_schema_actor.h
index 6d1f6ee3d3d..dee06f54112 100644
--- a/ydb/services/lib/actors/pq_schema_actor.h
+++ b/ydb/services/lib/actors/pq_schema_actor.h
@@ -425,7 +425,7 @@ namespace NKikimr::NGRpcProxy::V1 {
         }
 
     private:
-        THolder<NActors::TEventHandle<TEvTxProxySchemeCache::TEvNavigateKeySetResult>> DescribeSchemeResult;
+        THolder<TEvTxProxySchemeCache::TEvNavigateKeySetResult> DescribeSchemeResult;
     };
 
 }
diff --git a/ydb/services/metadata/ds_table/registration.h b/ydb/services/metadata/ds_table/registration.h
index 60f63ae2b04..307489238ad 100644
--- a/ydb/services/metadata/ds_table/registration.h
+++ b/ydb/services/metadata/ds_table/registration.h
@@ -36,7 +36,7 @@ public:
     }
 
     void Resend(const TActorIdentity& receiver) {
-        TActivationContext::Send(new IEventHandle(receiver, Sender, Event.Release()));
+        TActivationContext::Send(new IEventHandleFat(receiver, Sender, Event.Release()));
     }
 };
 
@@ -53,7 +53,7 @@ public:
     }
 
     template <class T>
-    void Add(TEventHandle<T>& ev) {
+    void Add(TEventHandleFat<T>& ev) {
         Add(ev.ReleaseBase(), ev.Sender);
     }
 
diff --git a/ydb/services/metadata/manager/generic_manager.h b/ydb/services/metadata/manager/generic_manager.h
index 9ee4fca2cc6..d4a12cbc534 100644
--- a/ydb/services/metadata/manager/generic_manager.h
+++ b/ydb/services/metadata/manager/generic_manager.h
@@ -52,7 +52,7 @@ private:
         auto result = promise.GetFuture();
         auto c = std::make_shared<TOperationsController>(std::move(promise));
         auto command = std::make_shared<TCommand>(patch.GetRecord(), manager, c, context);
-        TActivationContext::Send(new IEventHandle(NProvider::MakeServiceId(nodeId), {},
+        TActivationContext::Send(new IEventHandleFat(NProvider::MakeServiceId(nodeId), {},
             new NProvider::TEvObjectsOperation(command)));
         return result;
     }
diff --git a/ydb/services/metadata/secret/ut/ut_secret.cpp b/ydb/services/metadata/secret/ut/ut_secret.cpp
index 5945b3f44c7..50117688173 100644
--- a/ydb/services/metadata/secret/ut/ut_secret.cpp
+++ b/ydb/services/metadata/secret/ut/ut_secret.cpp
@@ -84,9 +84,9 @@ Y_UNIT_TEST_SUITE(Secret) {
         void CheckRuntime(TTestActorRuntime& runtime) {
             const auto pred = [this](TTestActorRuntimeBase&, TAutoPtr<IEventHandle>& event)->TTestActorRuntimeBase::EEventAction {
                 if (event->HasBuffer() && !event->HasEvent()) {
-                } else if (!event->GetBase()) {
+                } else if (!event->HasEvent()) {
                 } else {
-                    auto ptr = dynamic_cast<NMetadata::NProvider::TEvRefreshSubscriberData*>(event->GetBase());
+                    auto ptr = event->CastAsLocal<NMetadata::NProvider::TEvRefreshSubscriberData>();
                     if (ptr) {
                         CheckFound(ptr);
                     }
diff --git a/ydb/services/persqueue_cluster_discovery/cluster_discovery_service_ut.cpp b/ydb/services/persqueue_cluster_discovery/cluster_discovery_service_ut.cpp
index ef0651cd5e2..184a83e2af9 100644
--- a/ydb/services/persqueue_cluster_discovery/cluster_discovery_service_ut.cpp
+++ b/ydb/services/persqueue_cluster_discovery/cluster_discovery_service_ut.cpp
@@ -316,7 +316,7 @@ public:
 
         TActorId clientId = ActorSystem().AllocateEdgeActor();
         NHttp::THttpOutgoingRequestPtr httpRequest = NHttp::THttpOutgoingRequest::CreateRequestGet("http://[::1]:" + ToString(MonPort()) + path);
-        ActorSystem().Send(new NActors::IEventHandle(HttpProxyId_, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
+        ActorSystem().Send(new NActors::IEventHandleFat(HttpProxyId_, clientId, new NHttp::TEvHttpProxy::TEvHttpOutgoingRequest(httpRequest)), 0, true);
 
         return ActorSystem().GrabEdgeEvent<NHttp::TEvHttpProxy::TEvHttpIncomingResponse>(clientId);
     }
@@ -408,7 +408,7 @@ Y_UNIT_TEST_SUITE(TPQCDTest) {
             const TActorId sender = actorSystem.AllocateEdgeActor();
 
             actorSystem.Send(
-                new IEventHandle(NNetClassifier::MakeNetClassifierID(), sender,
+                new IEventHandleFat(NNetClassifier::MakeNetClassifierID(), sender,
                     new NNetClassifier::TEvNetClassifier::TEvSubscribe()
             ));
 
@@ -437,7 +437,7 @@ Y_UNIT_TEST_SUITE(TPQCDTest) {
             const TActorId sender = actorSystem.AllocateEdgeActor();
 
             actorSystem.Send(
-                new IEventHandle(NPQ::NClusterTracker::MakeClusterTrackerID(), sender,
+                new IEventHandleFat(NPQ::NClusterTracker::MakeClusterTrackerID(), sender,
                     new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe()
             ));
 
@@ -605,7 +605,7 @@ Y_UNIT_TEST_SUITE(TPQCDTest) {
             const TActorId sender = actorSystem.AllocateEdgeActor();
 
             actorSystem.Send(
-                new IEventHandle(NNetClassifier::MakeNetClassifierID(), sender,
+                new IEventHandleFat(NNetClassifier::MakeNetClassifierID(), sender,
                     new NNetClassifier::TEvNetClassifier::TEvSubscribe()
             ));
 
diff --git a/ydb/services/persqueue_v1/persqueue_ut.cpp b/ydb/services/persqueue_v1/persqueue_ut.cpp
index 839f5d282b7..1ed8db51f99 100644
--- a/ydb/services/persqueue_v1/persqueue_ut.cpp
+++ b/ydb/services/persqueue_v1/persqueue_ut.cpp
@@ -56,7 +56,7 @@ using namespace NNetClassifier;
 TAutoPtr<IEventHandle> GetClassifierUpdate(TServer& server, const TActorId sender) {
     auto& actorSystem = *server.GetRuntime();
     actorSystem.Send(
-            new IEventHandle(MakeNetClassifierID(), sender,
+            new IEventHandleFat(MakeNetClassifierID(), sender,
             new TEvNetClassifier::TEvSubscribe()
         ));
 
@@ -4205,7 +4205,7 @@ Y_UNIT_TEST_SUITE(TPersQueueTest) {
 
         const auto edgeActorID = setup.GetServer().GetRuntime()->AllocateEdgeActor();
 
-        setup.GetServer().GetRuntime()->Send(new IEventHandle(NPQ::NClusterTracker::MakeClusterTrackerID(), edgeActorID, new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe));
+        setup.GetServer().GetRuntime()->Send(new IEventHandleFat(NPQ::NClusterTracker::MakeClusterTrackerID(), edgeActorID, new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe));
         log << TLOG_INFO << "Wait for cluster tracker event";
         auto clustersUpdate = setup.GetServer().GetRuntime()->GrabEdgeEvent<NPQ::NClusterTracker::TEvClusterTracker::TEvClustersUpdate>();
 
@@ -4243,7 +4243,7 @@ Y_UNIT_TEST_SUITE(TPersQueueTest) {
         TInstant now(TInstant::Now());
         auto session = setup.InitWriteSession(GenerateSessionSetupWithPreferredCluster(setup.GetRemoteCluster()));
 
-        setup.GetServer().GetRuntime()->Send(new IEventHandle(NPQ::NClusterTracker::MakeClusterTrackerID(), edgeActorID, new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe));
+        setup.GetServer().GetRuntime()->Send(new IEventHandleFat(NPQ::NClusterTracker::MakeClusterTrackerID(), edgeActorID, new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe));
         log << TLOG_INFO << "Wait for cluster tracker event";
         auto clustersUpdate = setup.GetServer().GetRuntime()->GrabEdgeEvent<NPQ::NClusterTracker::TEvClusterTracker::TEvClustersUpdate>();
         AssertStreamingSessionAlive(session.first);
@@ -4267,7 +4267,7 @@ Y_UNIT_TEST_SUITE(TPersQueueTest) {
 
         setup.GetFlatMsgBusPQClient().UpdateDC(setup.GetRemoteCluster(), false, true);
 
-        setup.GetServer().GetRuntime()->Send(new IEventHandle(NPQ::NClusterTracker::MakeClusterTrackerID(), edgeActorID, new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe));
+        setup.GetServer().GetRuntime()->Send(new IEventHandleFat(NPQ::NClusterTracker::MakeClusterTrackerID(), edgeActorID, new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe));
         log << TLOG_INFO << "Wait for cluster tracker event";
         auto clustersUpdate = setup.GetServer().GetRuntime()->GrabEdgeEvent<NPQ::NClusterTracker::TEvClusterTracker::TEvClustersUpdate>();
         TInstant now(TInstant::Now());
@@ -5944,7 +5944,7 @@ Y_UNIT_TEST_SUITE(TPersQueueTest) {
         };
 
         auto getClustersFromTracker = [&]() {
-            setup.GetServer().GetRuntime()->Send(new IEventHandle(
+            setup.GetServer().GetRuntime()->Send(new IEventHandleFat(
                 NPQ::NClusterTracker::MakeClusterTrackerID(),
                 edgeActorID,
                 new NPQ::NClusterTracker::TEvClusterTracker::TEvSubscribe