diff --git a/client/src/client.rs b/client/src/client.rs
index f39840c22e4..c5ddff65fef 100644
--- a/client/src/client.rs
+++ b/client/src/client.rs
@@ -334,7 +334,7 @@ impl_query_result! {
     iroha_data_model::query::MetadataValue,
     iroha_data_model::query::TransactionQueryOutput,
     iroha_data_model::permission::PermissionTokenSchema,
-    iroha_data_model::trigger::Trigger<iroha_data_model::events::TriggeringFilterBox, iroha_data_model::transaction::Executable>,
+    iroha_data_model::trigger::Trigger<iroha_data_model::events::TriggeringFilterBox>,
 }
 
 /// Iroha client
diff --git a/core/src/smartcontracts/isi/mod.rs b/core/src/smartcontracts/isi/mod.rs
index ba59338c9fa..3baf3732653 100644
--- a/core/src/smartcontracts/isi/mod.rs
+++ b/core/src/smartcontracts/isi/mod.rs
@@ -88,8 +88,7 @@ impl Execute for RegisterExpr {
             }
             RegistrableBox::Asset(object) => Register::<Asset> { object }.execute(authority, wsv),
             RegistrableBox::Trigger(object) => {
-                Register::<Trigger<TriggeringFilterBox, Executable>> { object }
-                    .execute(authority, wsv)
+                Register::<Trigger<TriggeringFilterBox>> { object }.execute(authority, wsv)
             }
             RegistrableBox::Role(object) => Register::<Role> { object }.execute(authority, wsv),
         }
@@ -115,8 +114,7 @@ impl Execute for UnregisterExpr {
             IdBox::PeerId(object_id) => Unregister::<Peer> { object_id }.execute(authority, wsv),
             IdBox::RoleId(object_id) => Unregister::<Role> { object_id }.execute(authority, wsv),
             IdBox::TriggerId(object_id) => {
-                Unregister::<Trigger<TriggeringFilterBox, Executable>> { object_id }
-                    .execute(authority, wsv)
+                Unregister::<Trigger<TriggeringFilterBox>> { object_id }.execute(authority, wsv)
             }
             IdBox::PermissionTokenId(_) | IdBox::ParameterId(_) => {
                 Err(Error::Evaluate(InstructionType::Unregister.into()))
@@ -169,7 +167,7 @@ impl Execute for MintExpr {
                 .execute(authority, wsv)
             }
             (IdBox::TriggerId(destination_id), Value::Numeric(NumericValue::U32(object))) => {
-                Mint::<u32, Trigger<TriggeringFilterBox, Executable>> {
+                Mint::<u32, Trigger<TriggeringFilterBox>> {
                     object,
                     destination_id,
                 }
diff --git a/core/src/smartcontracts/isi/query.rs b/core/src/smartcontracts/isi/query.rs
index 33d2610a39c..3f8eb4e10c0 100644
--- a/core/src/smartcontracts/isi/query.rs
+++ b/core/src/smartcontracts/isi/query.rs
@@ -52,7 +52,7 @@ impl_lazy! {
     iroha_data_model::query::MetadataValue,
     iroha_data_model::query::TransactionQueryOutput,
     iroha_data_model::permission::PermissionTokenSchema,
-    iroha_data_model::trigger::Trigger<iroha_data_model::events::TriggeringFilterBox, iroha_data_model::transaction::Executable>,
+    iroha_data_model::trigger::Trigger<iroha_data_model::events::TriggeringFilterBox>,
 }
 
 /// Query Request statefully validated on the Iroha node side.
diff --git a/core/src/smartcontracts/isi/triggers/mod.rs b/core/src/smartcontracts/isi/triggers/mod.rs
index 6b6e265f99e..fbe31e230e0 100644
--- a/core/src/smartcontracts/isi/triggers/mod.rs
+++ b/core/src/smartcontracts/isi/triggers/mod.rs
@@ -22,7 +22,7 @@ pub mod isi {
 
     use super::{super::prelude::*, *};
 
-    impl Execute for Register<Trigger<TriggeringFilterBox, Executable>> {
+    impl Execute for Register<Trigger<TriggeringFilterBox>> {
         #[metrics(+"register_trigger")]
         #[allow(clippy::expect_used)]
         fn execute(self, _authority: &AccountId, wsv: &mut WorldStateView) -> Result<(), Error> {
@@ -82,7 +82,7 @@ pub mod isi {
         }
     }
 
-    impl Execute for Unregister<Trigger<TriggeringFilterBox, Executable>> {
+    impl Execute for Unregister<Trigger<TriggeringFilterBox>> {
         #[metrics(+"unregister_trigger")]
         fn execute(self, _authority: &AccountId, wsv: &mut WorldStateView) -> Result<(), Error> {
             let trigger_id = self.object_id.clone();
@@ -101,7 +101,7 @@ pub mod isi {
         }
     }
 
-    impl Execute for Mint<u32, Trigger<TriggeringFilterBox, Executable>> {
+    impl Execute for Mint<u32, Trigger<TriggeringFilterBox>> {
         #[metrics(+"mint_trigger_repetitions")]
         fn execute(self, _authority: &AccountId, wsv: &mut WorldStateView) -> Result<(), Error> {
             let id = self.destination_id;
@@ -133,7 +133,7 @@ pub mod isi {
         }
     }
 
-    impl Execute for Burn<u32, Trigger<TriggeringFilterBox, Executable>> {
+    impl Execute for Burn<u32, Trigger<TriggeringFilterBox>> {
         #[metrics(+"burn_trigger_repetitions")]
         fn execute(self, _authority: &AccountId, wsv: &mut WorldStateView) -> Result<(), Error> {
             let trigger = self.destination_id;
@@ -203,7 +203,7 @@ pub mod query {
     };
 
     use super::*;
-    use crate::{prelude::*, smartcontracts::triggers::set::LoadedExecutable};
+    use crate::prelude::*;
 
     impl ValidQuery for FindAllActiveTriggerIds {
         #[metrics(+"find_all_active_triggers")]
@@ -217,41 +217,19 @@ pub mod query {
 
     impl ValidQuery for FindTriggerById {
         #[metrics(+"find_trigger_by_id")]
-        fn execute(
-            &self,
-            wsv: &WorldStateView,
-        ) -> Result<Trigger<TriggeringFilterBox, Executable>, Error> {
+        fn execute(&self, wsv: &WorldStateView) -> Result<Trigger<TriggeringFilterBox>, Error> {
             let id = wsv
                 .evaluate(&self.id)
                 .map_err(|e| Error::Evaluate(format!("Failed to evaluate trigger id. {e}")))?;
             iroha_logger::trace!(%id);
             // Can't use just `ActionTrait::clone_and_box` cause this will trigger lifetime mismatch
             #[allow(clippy::redundant_closure_for_method_calls)]
-            let Action {
-                executable: loaded_executable,
-                repeats,
-                authority,
-                filter,
-                metadata,
-            } = wsv
+            let loaded_action = wsv
                 .triggers()
                 .inspect_by_id(&id, |action| action.clone_and_box())
                 .ok_or_else(|| Error::Find(FindError::Trigger(id.clone())))?;
 
-            let original_executable = match loaded_executable {
-                LoadedExecutable::Wasm(_) => {
-                    let original_wasm = wsv
-                        .triggers()
-                        .get_original_contract(&id)
-                        .cloned()
-                        .expect("No original smartcontract saved for trigger. This is a bug.");
-                    Executable::Wasm(original_wasm)
-                }
-                LoadedExecutable::Instructions(isi) => Executable::Instructions(isi),
-            };
-
-            let action = Action::new(original_executable, repeats, authority, filter)
-                .with_metadata(metadata);
+            let action = wsv.triggers().get_original_action(loaded_action);
 
             // TODO: Should we redact the metadata if the account is not the authority/owner?
             Ok(Trigger::new(id, action))
@@ -286,44 +264,22 @@ pub mod query {
         fn execute<'wsv>(
             &self,
             wsv: &'wsv WorldStateView,
-        ) -> eyre::Result<
-            Box<dyn Iterator<Item = Trigger<TriggeringFilterBox, Executable>> + 'wsv>,
-            Error,
-        > {
+        ) -> eyre::Result<Box<dyn Iterator<Item = Trigger<TriggeringFilterBox>> + 'wsv>, Error>
+        {
             let domain_id = wsv
                 .evaluate(&self.domain_id)
                 .map_err(|e| Error::Evaluate(format!("Failed to evaluate domain id. {e}")))?;
 
-            Ok(Box::new(wsv.triggers().inspect_by_domain_id(
-                &domain_id,
-                |trigger_id, action| {
-                    let Action {
-                        executable: loaded_executable,
-                        repeats,
-                        authority,
-                        filter,
-                        metadata,
-                    } = action.clone_and_box();
-
-                    let original_executable =
-                        match loaded_executable {
-                            LoadedExecutable::Wasm(_) => {
-                                let original_wasm =
-                                wsv.triggers().get_original_contract(&trigger_id).cloned().expect(
-                                    "No original smartcontract saved for trigger. This is a bug.",
-                                );
-                                Executable::Wasm(original_wasm)
-                            }
-                            LoadedExecutable::Instructions(isi) => Executable::Instructions(isi),
-                        };
-
-                    Trigger::new(
-                        trigger_id.clone(),
-                        Action::new(original_executable, repeats, authority, filter)
-                            .with_metadata(metadata),
-                    )
-                },
-            )))
+            Ok(Box::new(
+                wsv.triggers()
+                    .inspect_by_domain_id(&domain_id, |trigger_id, action| {
+                        (trigger_id.clone(), action.clone_and_box())
+                    })
+                    .map(|(trigger_id, action)| {
+                        let action = wsv.triggers().get_original_action(action);
+                        Trigger::new(trigger_id, action)
+                    }),
+            ))
         }
     }
 }
diff --git a/core/src/smartcontracts/isi/triggers/set.rs b/core/src/smartcontracts/isi/triggers/set.rs
index a87217bc188..6cfcdb70be0 100644
--- a/core/src/smartcontracts/isi/triggers/set.rs
+++ b/core/src/smartcontracts/isi/triggers/set.rs
@@ -17,7 +17,8 @@ use iroha_data_model::{
     isi::error::{InstructionExecutionError, MathError},
     prelude::*,
     query::error::FindError,
-    trigger::{action::ActionTrait, OptimizedExecutable, Trigger, WasmInternalRepr},
+    transaction::WasmSmartContract,
+    trigger::Trigger,
 };
 use serde::{
     de::{DeserializeSeed, MapAccess, Visitor},
@@ -39,7 +40,88 @@ pub enum Error {
 pub type Result<T, E = Error> = core::result::Result<T, E>;
 
 /// Type of action with pre-loaded executable.
-pub type LoadedAction<F> = Action<F, LoadedExecutable>;
+#[derive(Clone, Debug)]
+pub struct LoadedAction<F> {
+    executable: LoadedExecutable,
+    pub repeats: Repeats,
+    pub authority: AccountId,
+    pub filter: F,
+    pub metadata: Metadata,
+}
+
+pub trait LoadedActionTrait {
+    /// Get action executable
+    fn executable(&self) -> &LoadedExecutable;
+
+    /// Get action repeats enum
+    fn repeats(&self) -> &Repeats;
+
+    /// Set action repeats
+    fn set_repeats(&mut self, repeats: Repeats);
+
+    /// Get action technical account
+    fn authority(&self) -> &AccountId;
+
+    /// Get action metadata
+    fn metadata(&self) -> &Metadata;
+
+    /// Check if action is mintable.
+    fn mintable(&self) -> bool;
+
+    /// Convert action to a boxed representation
+    fn into_boxed(self) -> LoadedAction<TriggeringFilterBox>;
+
+    /// Same as [`into_boxed()`](ActionTrait::into_boxed) but clones `self`
+    fn clone_and_box(&self) -> LoadedAction<TriggeringFilterBox>;
+}
+
+impl<'a, F: Filter + Into<TriggeringFilterBox> + Clone> LoadedActionTrait for LoadedAction<F> {
+    fn executable(&self) -> &LoadedExecutable {
+        &self.executable
+    }
+
+    fn repeats(&self) -> &iroha_data_model::trigger::action::Repeats {
+        &self.repeats
+    }
+
+    fn set_repeats(&mut self, repeats: iroha_data_model::trigger::action::Repeats) {
+        self.repeats = repeats;
+    }
+
+    fn authority(&self) -> &AccountId {
+        &self.authority
+    }
+
+    fn metadata(&self) -> &Metadata {
+        &self.metadata
+    }
+
+    fn mintable(&self) -> bool {
+        self.filter.mintable()
+    }
+
+    fn into_boxed(self) -> LoadedAction<TriggeringFilterBox> {
+        let Self {
+            executable,
+            repeats,
+            authority,
+            filter,
+            metadata,
+        } = self;
+
+        LoadedAction {
+            executable,
+            repeats,
+            authority,
+            filter: filter.into(),
+            metadata,
+        }
+    }
+
+    fn clone_and_box(&self) -> LoadedAction<TriggeringFilterBox> {
+        self.clone().into_boxed()
+    }
+}
 
 /// Specialized structure that maps event filters to Triggers.
 // NB: `Set` has custom `Serialize` and `DeserializeSeed` implementations
@@ -57,7 +139,7 @@ pub struct Set {
     /// Trigger ids with type of events they process
     ids: HashMap<TriggerId, TriggeringEventType>,
     /// Original [`WasmSmartContract`]s by [`TriggerId`] for querying purposes.
-    original_contracts: HashMap<TriggerId, WasmSmartContract>,
+    original_contracts: HashMap<HashOf<WasmSmartContract>, WasmSmartContract>,
     /// List of actions that should be triggered by events provided by `handle_*` methods.
     /// Vector is used to save the exact triggers order.
     matched_ids: Vec<(Event, TriggerId)>,
@@ -85,7 +167,7 @@ impl<F: Clone + Serialize> Serialize for TriggersWithContext<'_, F> {
     {
         let mut map = serializer.serialize_map(Some(self.triggers.len()))?;
         for (id, action) in self.triggers.iter() {
-            let action = self.set.get_original_action(id, action.clone());
+            let action = self.set.get_original_action(action.clone());
             map.serialize_entry(&id, &action)?;
         }
         map.end()
@@ -145,7 +227,7 @@ impl<'de> DeserializeSeed<'de> for WasmSeed<'_, Set> {
                 while let Some(key) = map.next_key::<String>()? {
                     match key.as_str() {
                         "data_triggers" => {
-                            let triggers: HashMap<TriggerId, Action<DataEventFilter, Executable>> =
+                            let triggers: HashMap<TriggerId, Action<DataEventFilter>> =
                                 map.next_value()?;
                             for (id, action) in triggers {
                                 set.add_data_trigger(self.loader.engine, Trigger::new(id, action))
@@ -153,10 +235,8 @@ impl<'de> DeserializeSeed<'de> for WasmSeed<'_, Set> {
                             }
                         }
                         "pipeline_triggers" => {
-                            let triggers: HashMap<
-                                TriggerId,
-                                Action<PipelineEventFilter, Executable>,
-                            > = map.next_value()?;
+                            let triggers: HashMap<TriggerId, Action<PipelineEventFilter>> =
+                                map.next_value()?;
                             for (id, action) in triggers {
                                 set.add_pipeline_trigger(
                                     self.loader.engine,
@@ -166,7 +246,7 @@ impl<'de> DeserializeSeed<'de> for WasmSeed<'_, Set> {
                             }
                         }
                         "time_triggers" => {
-                            let triggers: HashMap<TriggerId, Action<TimeEventFilter, Executable>> =
+                            let triggers: HashMap<TriggerId, Action<TimeEventFilter>> =
                                 map.next_value()?;
                             for (id, action) in triggers {
                                 set.add_time_trigger(self.loader.engine, Trigger::new(id, action))
@@ -174,10 +254,8 @@ impl<'de> DeserializeSeed<'de> for WasmSeed<'_, Set> {
                             }
                         }
                         "by_call_triggers" => {
-                            let triggers: HashMap<
-                                TriggerId,
-                                Action<ExecuteTriggerEventFilter, Executable>,
-                            > = map.next_value()?;
+                            let triggers: HashMap<TriggerId, Action<ExecuteTriggerEventFilter>> =
+                                map.next_value()?;
                             for (id, action) in triggers {
                                 set.add_by_call_trigger(
                                     self.loader.engine,
@@ -227,7 +305,7 @@ impl Set {
     pub fn add_data_trigger(
         &mut self,
         engine: &wasmtime::Engine,
-        trigger: Trigger<DataEventFilter, Executable>,
+        trigger: Trigger<DataEventFilter>,
     ) -> Result<bool> {
         self.add_to(engine, trigger, TriggeringEventType::Data, |me| {
             &mut me.data_triggers
@@ -245,7 +323,7 @@ impl Set {
     pub fn add_pipeline_trigger(
         &mut self,
         engine: &wasmtime::Engine,
-        trigger: Trigger<PipelineEventFilter, Executable>,
+        trigger: Trigger<PipelineEventFilter>,
     ) -> Result<bool> {
         self.add_to(engine, trigger, TriggeringEventType::Pipeline, |me| {
             &mut me.pipeline_triggers
@@ -263,7 +341,7 @@ impl Set {
     pub fn add_time_trigger(
         &mut self,
         engine: &wasmtime::Engine,
-        trigger: Trigger<TimeEventFilter, Executable>,
+        trigger: Trigger<TimeEventFilter>,
     ) -> Result<bool> {
         self.add_to(engine, trigger, TriggeringEventType::Time, |me| {
             &mut me.time_triggers
@@ -281,7 +359,7 @@ impl Set {
     pub fn add_by_call_trigger(
         &mut self,
         engine: &wasmtime::Engine,
-        trigger: Trigger<ExecuteTriggerEventFilter, Executable>,
+        trigger: Trigger<ExecuteTriggerEventFilter>,
     ) -> Result<bool> {
         self.add_to(engine, trigger, TriggeringEventType::ExecuteTrigger, |me| {
             &mut me.by_call_triggers
@@ -298,7 +376,7 @@ impl Set {
     fn add_to<F: Filter>(
         &mut self,
         engine: &wasmtime::Engine,
-        trigger: Trigger<F, Executable>,
+        trigger: Trigger<F>,
         event_type: TriggeringEventType,
         map: impl FnOnce(&mut Self) -> &mut HashMap<TriggerId, LoadedAction<F>>,
     ) -> Result<bool> {
@@ -317,12 +395,13 @@ impl Set {
 
         let loaded_executable = match executable {
             Executable::Wasm(bytes) => {
+                let hash = HashOf::new(&bytes);
                 let loaded = LoadedExecutable::Wasm(LoadedWasm {
                     module: wasm::load_module(engine, &bytes)?,
-                    blob_hash: HashOf::new(&bytes),
+                    blob_hash: hash,
                 });
                 // Store original executable representation to respond to queries with.
-                self.original_contracts.insert(trigger_id.clone(), bytes);
+                self.original_contracts.insert(hash, bytes);
                 loaded
             }
             Executable::Instructions(instructions) => LoadedExecutable::Instructions(instructions),
@@ -345,16 +424,15 @@ impl Set {
     /// Returns `None` if there's no [`Trigger`]
     /// with specified `id` that has WASM executable
     #[inline]
-    pub fn get_original_contract(&self, id: &TriggerId) -> Option<&WasmSmartContract> {
-        self.original_contracts.get(id)
+    pub fn get_original_contract(
+        &self,
+        hash: &HashOf<WasmSmartContract>,
+    ) -> Option<&WasmSmartContract> {
+        self.original_contracts.get(hash)
     }
 
-    fn get_original_action<F: Clone>(
-        &self,
-        id: &TriggerId,
-        action: LoadedAction<F>,
-    ) -> Action<F, Executable> {
-        let Action {
+    pub fn get_original_action<F: Clone>(&self, action: LoadedAction<F>) -> Action<F> {
+        let LoadedAction {
             executable,
             repeats,
             authority,
@@ -363,9 +441,9 @@ impl Set {
         } = action;
 
         let original_executable = match executable {
-            LoadedExecutable::Wasm(_) => {
+            LoadedExecutable::Wasm(LoadedWasm { ref blob_hash, .. }) => {
                 let original_wasm = self
-                    .get_original_contract(id)
+                    .get_original_contract(blob_hash)
                     .cloned()
                     .expect("No original smartcontract saved for trigger. This is a bug.");
                 Executable::Wasm(original_wasm)
@@ -388,6 +466,41 @@ impl Set {
         self.ids.keys()
     }
 
+    pub fn get_executable(&self, id: &TriggerId) -> Option<&LoadedExecutable> {
+        let event_type = self.ids.get(id)?;
+
+        Some(match event_type {
+            TriggeringEventType::Data => {
+                &self
+                    .data_triggers
+                    .get(id)
+                    .expect("`Set::data_triggers` doesn't contain required id. This is a bug")
+                    .executable
+            }
+            TriggeringEventType::Pipeline => {
+                &self
+                    .pipeline_triggers
+                    .get(id)
+                    .expect("`Set::pipeline_triggers` doesn't contain required id. This is a bug")
+                    .executable
+            }
+            TriggeringEventType::Time => {
+                &self
+                    .time_triggers
+                    .get(id)
+                    .expect("`Set::time_triggers` doesn't contain required id. This is a bug")
+                    .executable
+            }
+            TriggeringEventType::ExecuteTrigger => {
+                &self
+                    .by_call_triggers
+                    .get(id)
+                    .expect("`Set::by_call_triggers` doesn't contain required id. This is a bug")
+                    .executable
+            }
+        })
+    }
+
     /// Apply `f` to triggers that belong to the given [`DomainId`]
     ///
     /// Return an empty list if [`Set`] doesn't contain any triggers belonging to [`DomainId`].
@@ -397,7 +510,7 @@ impl Set {
         f: F,
     ) -> impl Iterator<Item = R> + '_
     where
-        F: Fn(&TriggerId, &dyn ActionTrait<Executable = LoadedExecutable>) -> R,
+        F: Fn(&TriggerId, &dyn LoadedActionTrait) -> R,
     {
         let domain_id = domain_id.clone();
 
@@ -440,7 +553,7 @@ impl Set {
     /// Return [`None`] if [`Set`] doesn't contain the trigger with the given `id`.
     pub fn inspect_by_id<F, R>(&self, id: &TriggerId, f: F) -> Option<R>
     where
-        F: Fn(&dyn ActionTrait<Executable = LoadedExecutable>) -> R,
+        F: Fn(&dyn LoadedActionTrait) -> R,
     {
         let event_type = self.ids.get(id).copied()?;
 
@@ -474,7 +587,7 @@ impl Set {
     /// Return [`None`] if [`Set`] doesn't contain the trigger with the given `id`.
     pub fn inspect_by_id_mut<F, R>(&mut self, id: &TriggerId, f: F) -> Option<R>
     where
-        F: Fn(&mut dyn ActionTrait<Executable = LoadedExecutable>) -> R,
+        F: Fn(&mut dyn LoadedActionTrait) -> R,
     {
         let event_type = self.ids.get(id).copied()?;
 
@@ -507,32 +620,50 @@ impl Set {
     ///
     /// Return `false` if [`Set`] doesn't contain the trigger with the given `id`.
     pub fn remove(&mut self, id: &TriggerId) -> bool {
-        self.original_contracts.remove(id);
-        self.ids
-            .remove(id)
-            .map(|event_type| match event_type {
+        if let Some(event_type) = self.ids.remove(id) {
+            let blob_hash = match event_type {
                 TriggeringEventType::Data => self
                     .data_triggers
                     .remove(id)
-                    .map(|_| ())
+                    .map(|trigger| match trigger.executable {
+                        LoadedExecutable::Wasm(LoadedWasm { blob_hash, .. }) => Some(blob_hash),
+                        _ => None,
+                    })
                     .expect("`Set::data_triggers` doesn't contain required id. This is a bug"),
-                TriggeringEventType::Pipeline => {
-                    self.pipeline_triggers.remove(id).map(|_| ()).expect(
-                        "`Set::pipeline_triggers` doesn't contain required id. This is a bug",
-                    )
-                }
+                TriggeringEventType::Pipeline => self
+                    .pipeline_triggers
+                    .remove(id)
+                    .map(|trigger| match trigger.executable {
+                        LoadedExecutable::Wasm(LoadedWasm { blob_hash, .. }) => Some(blob_hash),
+                        _ => None,
+                    })
+                    .expect("`Set::pipeline_triggers` doesn't contain required id. This is a bug"),
                 TriggeringEventType::Time => self
                     .time_triggers
                     .remove(id)
-                    .map(|_| ())
+                    .map(|trigger| match trigger.executable {
+                        LoadedExecutable::Wasm(LoadedWasm { blob_hash, .. }) => Some(blob_hash),
+                        _ => None,
+                    })
                     .expect("`Set::time_triggers` doesn't contain required id. This is a bug"),
-                TriggeringEventType::ExecuteTrigger => {
-                    self.by_call_triggers.remove(id).map(|_| ()).expect(
-                        "`Set::by_call_triggers` doesn't contain required id. This is a bug",
-                    )
-                }
-            })
-            .is_some()
+                TriggeringEventType::ExecuteTrigger => self
+                    .by_call_triggers
+                    .remove(id)
+                    .map(|trigger| match trigger.executable {
+                        LoadedExecutable::Wasm(LoadedWasm { blob_hash, .. }) => Some(blob_hash),
+                        _ => None,
+                    })
+                    .expect("`Set::by_call_triggers` doesn't contain required id. This is a bug"),
+            };
+
+            if let Some(blob_hash) = blob_hash {
+                self.original_contracts.remove(&blob_hash).expect(
+                    "`Set::original_contracts` doesn't contain required hash. This is a bug",
+                );
+            }
+        }
+
+        false
     }
 
     /// Check if [`Set`] contains `id`.
@@ -735,24 +866,6 @@ impl core::fmt::Debug for LoadedExecutable {
     }
 }
 
-impl From<LoadedExecutable> for OptimizedExecutable {
-    fn from(executable: LoadedExecutable) -> Self {
-        match executable {
-            LoadedExecutable::Wasm(LoadedWasm { module, blob_hash }) => {
-                OptimizedExecutable::WasmInternalRepr(WasmInternalRepr {
-                    serialized: module
-                        .serialize()
-                        .expect("Serialization of optimized wasm module should always succeed"),
-                    blob_hash,
-                })
-            }
-            LoadedExecutable::Instructions(instructions) => {
-                OptimizedExecutable::Instructions(instructions)
-            }
-        }
-    }
-}
-
 /// [`Set::mod_repeats()`] error
 #[derive(Debug, Clone, thiserror::Error, displaydoc::Display)]
 pub enum ModRepeatsError {
diff --git a/core/src/wsv.rs b/core/src/wsv.rs
index 7a5c9073de3..ee6010866e8 100644
--- a/core/src/wsv.rs
+++ b/core/src/wsv.rs
@@ -31,7 +31,6 @@ use iroha_data_model::{
     permission::PermissionTokenSchema,
     prelude::*,
     query::error::{FindError, QueryExecutionFail},
-    trigger::action::ActionTrait,
 };
 use iroha_logger::prelude::*;
 use iroha_primitives::small::SmallVec;
@@ -48,7 +47,7 @@ use crate::{
     smartcontracts::{
         triggers::{
             self,
-            set::{LoadedExecutable, LoadedWasm, Set as TriggerSet},
+            set::{LoadedActionTrait, LoadedWasm, Set as TriggerSet},
         },
         wasm, Execute,
     },
@@ -518,7 +517,7 @@ impl WorldStateView {
     fn process_trigger(
         &mut self,
         id: &TriggerId,
-        action: &dyn ActionTrait<Executable = LoadedExecutable>,
+        action: &dyn LoadedActionTrait,
         event: Event,
     ) -> Result<()> {
         use triggers::set::LoadedExecutable::*;
diff --git a/data_model/src/events/data/events.rs b/data_model/src/events/data/events.rs
index c6dfe09c0fe..457e8fd2092 100644
--- a/data_model/src/events/data/events.rs
+++ b/data_model/src/events/data/events.rs
@@ -472,7 +472,7 @@ mod trigger {
     use super::*;
 
     data_event! {
-        #[has_origin(origin = Trigger<FilterBox, Executable>)]
+        #[has_origin(origin = Trigger<FilterBox>)]
         pub enum TriggerEvent {
             Created(TriggerId),
             Deleted(TriggerId),
diff --git a/data_model/src/lib.rs b/data_model/src/lib.rs
index 90bac808f97..ac3fd3acb43 100644
--- a/data_model/src/lib.rs
+++ b/data_model/src/lib.rs
@@ -639,7 +639,7 @@ pub mod model {
         Asset(<asset::Asset as Registered>::With),
         /// [`Trigger`](`trigger::Trigger`) variant.
         #[display(fmt = "Trigger {_0}")]
-        Trigger(<trigger::Trigger<TriggeringFilterBox, Executable> as Registered>::With),
+        Trigger(<trigger::Trigger<TriggeringFilterBox> as Registered>::With),
         /// [`Role`](`role::Role`) variant.
         #[display(fmt = "Role {_0}")]
         Role(<role::Role as Registered>::With),
@@ -681,40 +681,14 @@ pub mod model {
         AssetDefinition(asset::AssetDefinition),
         /// [`Asset`](`asset::Asset`) variant.
         Asset(asset::Asset),
-        /// [`TriggerBox`] variant.
-        Trigger(TriggerBox),
+        /// [`Trigger`](`trigger::Trigger`) variant.
+        Trigger(trigger::Trigger<TriggeringFilterBox>),
         /// [`Role`](`role::Role`) variant.
         Role(role::Role),
         /// [`Parameter`](`parameter::Parameter`) variant.
         Parameter(parameter::Parameter),
     }
 
-    /// Sized container for triggers with different executables.
-    #[derive(
-        Debug,
-        Display,
-        Clone,
-        PartialEq,
-        Eq,
-        PartialOrd,
-        Ord,
-        FromVariant,
-        Decode,
-        Encode,
-        Deserialize,
-        Serialize,
-        IntoSchema,
-    )]
-    #[ffi_type]
-    pub enum TriggerBox {
-        /// Un-optimized [`Trigger`](`trigger::Trigger`) submitted from client to Iroha.
-        #[display(fmt = "{_0}")]
-        Raw(trigger::Trigger<TriggeringFilterBox, Executable>),
-        /// Optimized [`Trigger`](`trigger::Trigger`) returned from Iroha to client.
-        #[display(fmt = "{_0} (optimised)")]
-        Optimized(trigger::Trigger<TriggeringFilterBox, trigger::OptimizedExecutable>),
-    }
-
     /// Sized container for all possible upgradable entities.
     #[derive(
         Debug,
@@ -993,17 +967,6 @@ pub mod model {
     }
 }
 
-impl Identifiable for TriggerBox {
-    type Id = trigger::TriggerId;
-
-    fn id(&self) -> &Self::Id {
-        match self {
-            TriggerBox::Raw(trigger) => trigger.id(),
-            TriggerBox::Optimized(trigger) => trigger.id(),
-        }
-    }
-}
-
 // TODO: think of a way to `impl Identifiable for IdentifiableBox`.
 // The main problem is lifetimes and conversion cost.
 
@@ -1322,7 +1285,7 @@ from_and_try_from_value_identifiable!(
     Account(account::Account),
     AssetDefinition(asset::AssetDefinition),
     Asset(asset::Asset),
-    Trigger(TriggerBox),
+    Trigger(trigger::Trigger<TriggeringFilterBox>),
     Role(role::Role),
     Parameter(parameter::Parameter),
 );
@@ -1375,13 +1338,10 @@ impl TryFrom<IdentifiableBox> for RegistrableBox {
             }
             NewRole(role) => Ok(RegistrableBox::Role(role)),
             Asset(asset) => Ok(RegistrableBox::Asset(asset)),
-            Trigger(TriggerBox::Raw(trigger)) => Ok(RegistrableBox::Trigger(trigger)),
-            Domain(_)
-            | Account(_)
-            | AssetDefinition(_)
-            | Role(_)
-            | Parameter(_)
-            | Trigger(TriggerBox::Optimized(_)) => Err(Self::Error::default()),
+            Trigger(trigger) => Ok(RegistrableBox::Trigger(trigger)),
+            Domain(_) | Account(_) | AssetDefinition(_) | Role(_) | Parameter(_) => {
+                Err(Self::Error::default())
+            }
         }
     }
 }
@@ -1399,7 +1359,7 @@ impl From<RegistrableBox> for IdentifiableBox {
             }
             Role(role) => IdentifiableBox::NewRole(role),
             Asset(asset) => IdentifiableBox::Asset(asset),
-            Trigger(trigger) => IdentifiableBox::Trigger(TriggerBox::Raw(trigger)),
+            Trigger(trigger) => IdentifiableBox::Trigger(trigger),
         }
     }
 }
@@ -1469,42 +1429,23 @@ impl TryFrom<f64> for Value {
     }
 }
 
-impl From<trigger::Trigger<TriggeringFilterBox, Executable>> for Value {
-    fn from(trigger: trigger::Trigger<TriggeringFilterBox, Executable>) -> Self {
-        Value::Identifiable(IdentifiableBox::Trigger(TriggerBox::Raw(trigger)))
-    }
-}
-
-impl From<trigger::Trigger<TriggeringFilterBox, trigger::OptimizedExecutable>> for Value {
-    fn from(trigger: trigger::Trigger<TriggeringFilterBox, trigger::OptimizedExecutable>) -> Self {
-        Value::Identifiable(IdentifiableBox::Trigger(TriggerBox::Optimized(trigger)))
-    }
-}
-
-impl TryFrom<Value> for trigger::Trigger<TriggeringFilterBox, Executable> {
-    type Error = ErrorTryFromEnum<Value, Self>;
-
-    fn try_from(value: Value) -> Result<Self, Self::Error> {
-        if let Value::Identifiable(IdentifiableBox::Trigger(TriggerBox::Raw(trigger))) = value {
-            return Ok(trigger);
-        }
-
-        Err(Self::Error::default())
-    }
-}
-
-impl TryFrom<Value> for trigger::Trigger<TriggeringFilterBox, trigger::OptimizedExecutable> {
-    type Error = ErrorTryFromEnum<Value, Self>;
-
-    fn try_from(value: Value) -> Result<Self, Self::Error> {
-        if let Value::Identifiable(IdentifiableBox::Trigger(TriggerBox::Optimized(trigger))) = value
-        {
-            return Ok(trigger);
-        }
-
-        Err(Self::Error::default())
-    }
-}
+// impl From<trigger::Trigger<TriggeringFilterBox>> for Value {
+//     fn from(trigger: trigger::Trigger<TriggeringFilterBox>) -> Self {
+//         Value::Identifiable(IdentifiableBox::Trigger(trigger))
+//     }
+// }
+//
+// impl TryFrom<Value> for trigger::Trigger<TriggeringFilterBox> {
+//     type Error = ErrorTryFromEnum<Value, Self>;
+//
+//     fn try_from(value: Value) -> Result<Self, Self::Error> {
+//         if let Value::Identifiable(IdentifiableBox::Trigger(trigger)) = value {
+//             return Ok(trigger);
+//         }
+//
+//         Err(Self::Error::default())
+//     }
+// }
 
 impl TryFrom<Value> for UpgradableBox {
     type Error = ErrorTryFromEnum<Value, Self>;
@@ -1949,7 +1890,7 @@ pub mod prelude {
         name::prelude::*, parameter::prelude::*, peer::prelude::*, permission::prelude::*,
         query::prelude::*, role::prelude::*, transaction::prelude::*, trigger::prelude::*,
         validator::prelude::*, EnumTryAsError, HasMetadata, IdBox, Identifiable, IdentifiableBox,
-        LengthLimits, NumericValue, PredicateTrait, RegistrableBox, ToValue, TriggerBox, TryAsMut,
-        TryAsRef, TryToValue, UpgradableBox, ValidationFail, Value,
+        LengthLimits, NumericValue, PredicateTrait, RegistrableBox, ToValue, TryAsMut, TryAsRef,
+        TryToValue, UpgradableBox, ValidationFail, Value,
     };
 }
diff --git a/data_model/src/query/mod.rs b/data_model/src/query/mod.rs
index 622010988bd..44e4025606a 100644
--- a/data_model/src/query/mod.rs
+++ b/data_model/src/query/mod.rs
@@ -1053,7 +1053,7 @@ pub mod trigger {
     }
 
     impl Query for FindTriggerById {
-        type Output = Trigger<TriggeringFilterBox, Executable>;
+        type Output = Trigger<TriggeringFilterBox>;
     }
 
     impl Query for FindTriggerKeyValueByIdAndKey {
@@ -1061,7 +1061,7 @@ pub mod trigger {
     }
 
     impl Query for FindTriggersByDomainId {
-        type Output = Vec<Trigger<TriggeringFilterBox, Executable>>;
+        type Output = Vec<Trigger<TriggeringFilterBox>>;
     }
 
     impl FindTriggerById {
diff --git a/data_model/src/trigger.rs b/data_model/src/trigger.rs
index 48d6e5a7ed9..93e839e9370 100644
--- a/data_model/src/trigger.rs
+++ b/data_model/src/trigger.rs
@@ -7,7 +7,7 @@ use core::{cmp, str::FromStr};
 use derive_more::{Constructor, Display};
 use getset::Getters;
 use iroha_data_model_derive::{model, IdEqOrdHash};
-use iroha_macro::{ffi_impl_opaque, FromVariant};
+use iroha_macro::ffi_impl_opaque;
 use iroha_schema::IntoSchema;
 use parity_scale_codec::{Decode, Encode};
 use serde::{Deserialize, Serialize};
@@ -15,8 +15,8 @@ use serde_with::{DeserializeFromStr, SerializeDisplay};
 
 pub use self::model::*;
 use crate::{
-    domain::DomainId, events::prelude::*, metadata::Metadata, prelude::InstructionExpr,
-    transaction::Executable, Identifiable, Name, ParseError, Registered,
+    domain::DomainId, events::prelude::*, metadata::Metadata, transaction::Executable,
+    Identifiable, Name, ParseError, Registered,
 };
 
 #[model]
@@ -64,62 +64,38 @@ pub mod model {
     )]
     #[display(fmt = "@@{id}")]
     #[ffi_type]
-    pub struct Trigger<F, E> {
+    pub struct Trigger<F> {
         /// [`Id`] of the [`Trigger`].
         pub id: TriggerId,
         /// Action to be performed when the trigger matches.
-        pub action: action::Action<F, E>,
-    }
-
-    /// Internal representation of Wasm blob provided by preloading it with `wasmtime` crate.
-    #[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-    pub struct WasmInternalRepr {
-        /// Serialized with `wasmtime::Module::serialize`
-        pub serialized: Vec<u8>,
-        /// Hash of original WASM blob on blockchain
-        pub blob_hash: iroha_crypto::HashOf<crate::transaction::WasmSmartContract>,
-    }
-
-    /// Same as [`Executable`] but instead of [`Wasm`](Executable::Wasm) contains
-    /// [`WasmInternalRepr`] with serialized optimized representation
-    /// from `wasmtime` library.
-    #[derive(
-        Debug, Clone, PartialEq, Eq, FromVariant, Decode, Encode, Deserialize, Serialize, IntoSchema,
-    )]
-    // TODO: Made opaque temporarily
-    #[ffi_type(opaque)]
-    pub enum OptimizedExecutable {
-        /// WASM serialized with `wasmtime`.
-        WasmInternalRepr(WasmInternalRepr),
-        /// Vector of [`instructions`](InstructionExpr).
-        Instructions(Vec<InstructionExpr>),
+        pub action: action::Action<F>,
     }
 }
 
 #[ffi_impl_opaque]
-impl Trigger<TriggeringFilterBox, OptimizedExecutable> {
+impl Trigger<TriggeringFilterBox> {
     /// [`Id`] of the [`Trigger`].
     pub fn id(&self) -> &TriggerId {
         &self.id
     }
 
     /// Action to be performed when the trigger matches.
-    pub fn action(&self) -> &action::Action<TriggeringFilterBox, OptimizedExecutable> {
+    pub fn action(&self) -> &action::Action<TriggeringFilterBox> {
         &self.action
     }
 }
 
-impl Registered for Trigger<TriggeringFilterBox, Executable> {
+impl Registered for Trigger<TriggeringFilterBox> {
     type With = Self;
 }
 
 macro_rules! impl_try_from_box {
     ($($variant:ident => $filter_type:ty),+ $(,)?) => {
         $(
-            impl<E> TryFrom<Trigger<TriggeringFilterBox, E>> for Trigger<$filter_type, E> {
+            impl TryFrom<Trigger<TriggeringFilterBox>> for Trigger<$filter_type> {
                 type Error = &'static str;
 
-                fn try_from(boxed: Trigger<TriggeringFilterBox, E>) -> Result<Self, Self::Error> {
+                fn try_from(boxed: Trigger<TriggeringFilterBox>) -> Result<Self, Self::Error> {
                     if let TriggeringFilterBox::$variant(concrete_filter) = boxed.action.filter {
                         let action = action::Action::new(
                             boxed.action.executable,
@@ -210,9 +186,9 @@ pub mod action {
             Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema,
         )]
         #[ffi_type]
-        pub struct Action<F, E> {
+        pub struct Action<F> {
             /// The executable linked to this action
-            pub executable: E,
+            pub executable: Executable,
             /// The repeating scheme of the action. It's kept as part of the
             /// action and not inside the [`Trigger`] type, so that further
             /// sanity checking can be done.
@@ -239,16 +215,16 @@ pub mod action {
     }
 
     #[cfg(feature = "transparent_api")]
-    impl<F, E> crate::HasMetadata for Action<F, E> {
+    impl<F> crate::HasMetadata for Action<F> {
         fn metadata(&self) -> &crate::metadata::Metadata {
             &self.metadata
         }
     }
 
     #[ffi_impl_opaque]
-    impl Action<TriggeringFilterBox, OptimizedExecutable> {
+    impl Action<TriggeringFilterBox> {
         /// The executable linked to this action
-        pub fn executable(&self) -> &OptimizedExecutable {
+        pub fn executable(&self) -> &Executable {
             &self.executable
         }
         /// The repeating scheme of the action. It's kept as part of the
@@ -267,10 +243,10 @@ pub mod action {
         }
     }
 
-    impl<F, E> Action<F, E> {
+    impl<F> Action<F> {
         /// Construct an action given `executable`, `repeats`, `authority` and `filter`.
         pub fn new(
-            executable: impl Into<E>,
+            executable: impl Into<Executable>,
             repeats: impl Into<Repeats>,
             authority: AccountId,
             filter: F,
@@ -293,7 +269,7 @@ pub mod action {
         }
     }
 
-    impl<F: PartialEq, E: PartialEq> PartialOrd for Action<F, E> {
+    impl<F: PartialEq> PartialOrd for Action<F> {
         fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
             // Exclude the executable. When debugging and replacing
             // the trigger, its position in Hash and Tree maps should
@@ -307,7 +283,7 @@ pub mod action {
     }
 
     #[allow(clippy::expect_used)]
-    impl<F: Eq, E: Eq> Ord for Action<F, E> {
+    impl<F: Eq> Ord for Action<F> {
         fn cmp(&self, other: &Self) -> cmp::Ordering {
             self.partial_cmp(other)
                 .expect("`PartialCmp::partial_cmp()` for `Action` should never return `None`")
@@ -317,11 +293,8 @@ pub mod action {
     /// Trait for common methods for all [`Action`]'s
     #[cfg(feature = "transparent_api")]
     pub trait ActionTrait {
-        /// Type of action executable
-        type Executable;
-
         /// Get action executable
-        fn executable(&self) -> &Self::Executable;
+        fn executable(&self) -> &Executable;
 
         /// Get action repeats enum
         fn repeats(&self) -> &Repeats;
@@ -339,17 +312,15 @@ pub mod action {
         fn mintable(&self) -> bool;
 
         /// Convert action to a boxed representation
-        fn into_boxed(self) -> Action<TriggeringFilterBox, Self::Executable>;
+        fn into_boxed(self) -> Action<TriggeringFilterBox>;
 
         /// Same as [`into_boxed()`](ActionTrait::into_boxed) but clones `self`
-        fn clone_and_box(&self) -> Action<TriggeringFilterBox, Self::Executable>;
+        fn clone_and_box(&self) -> Action<TriggeringFilterBox>;
     }
 
     #[cfg(feature = "transparent_api")]
-    impl<F: Filter + Into<TriggeringFilterBox> + Clone, E: Clone> ActionTrait for Action<F, E> {
-        type Executable = E;
-
-        fn executable(&self) -> &Self::Executable {
+    impl<F: Filter + Into<TriggeringFilterBox> + Clone> ActionTrait for Action<F> {
+        fn executable(&self) -> &Executable {
             &self.executable
         }
 
@@ -373,8 +344,8 @@ pub mod action {
             self.filter.mintable()
         }
 
-        fn into_boxed(self) -> Action<TriggeringFilterBox, Self::Executable> {
-            Action::<TriggeringFilterBox, Self::Executable> {
+        fn into_boxed(self) -> Action<TriggeringFilterBox> {
+            Action::<TriggeringFilterBox> {
                 executable: self.executable,
                 repeats: self.repeats,
                 authority: self.authority,
@@ -383,8 +354,8 @@ pub mod action {
             }
         }
 
-        fn clone_and_box(&self) -> Action<TriggeringFilterBox, Self::Executable> {
-            Action::<TriggeringFilterBox, Self::Executable> {
+        fn clone_and_box(&self) -> Action<TriggeringFilterBox> {
+            Action::<TriggeringFilterBox> {
                 executable: self.executable.clone(),
                 repeats: self.repeats.clone(),
                 authority: self.authority.clone(),
@@ -439,23 +410,17 @@ mod tests {
     fn trigger_with_filterbox_can_be_unboxed() {
         /// Should fail to compile if a new variant will be added to `TriggeringFilterBox`
         #[allow(dead_code, clippy::unwrap_used)]
-        fn compile_time_check(boxed: Trigger<TriggeringFilterBox, Executable>) {
+        fn compile_time_check(boxed: Trigger<TriggeringFilterBox>) {
             match &boxed.action.filter {
-                TriggeringFilterBox::Data(_) => {
-                    Trigger::<DataEventFilter, Executable>::try_from(boxed)
-                        .map(|_| ())
-                        .unwrap()
-                }
-                TriggeringFilterBox::Pipeline(_) => {
-                    Trigger::<PipelineEventFilter, Executable>::try_from(boxed)
-                        .map(|_| ())
-                        .unwrap()
-                }
-                TriggeringFilterBox::Time(_) => {
-                    Trigger::<TimeEventFilter, Executable>::try_from(boxed)
-                        .map(|_| ())
-                        .unwrap()
-                }
+                TriggeringFilterBox::Data(_) => Trigger::<DataEventFilter>::try_from(boxed)
+                    .map(|_| ())
+                    .unwrap(),
+                TriggeringFilterBox::Pipeline(_) => Trigger::<PipelineEventFilter>::try_from(boxed)
+                    .map(|_| ())
+                    .unwrap(),
+                TriggeringFilterBox::Time(_) => Trigger::<TimeEventFilter>::try_from(boxed)
+                    .map(|_| ())
+                    .unwrap(),
                 TriggeringFilterBox::ExecuteTrigger(_) => {
                     Trigger::<ExecuteTriggerEventFilter, Executable>::try_from(boxed)
                         .map(|_| ())
diff --git a/data_model/src/visit.rs b/data_model/src/visit.rs
index 7ef7be8a2b0..174b013c2be 100644
--- a/data_model/src/visit.rs
+++ b/data_model/src/visit.rs
@@ -115,7 +115,7 @@ pub trait Visit: ExpressionEvaluator {
         visit_register_asset_definition(Register<AssetDefinition>),
         visit_register_asset(Register<Asset>),
         visit_register_role(Register<Role>),
-        visit_register_trigger(Register<Trigger<TriggeringFilterBox, Executable>>),
+        visit_register_trigger(Register<Trigger<TriggeringFilterBox>>),
 
         // Visit UnregisterExpr
         visit_unregister_peer(Unregister<Peer>),
@@ -125,13 +125,13 @@ pub trait Visit: ExpressionEvaluator {
         visit_unregister_asset(Unregister<Asset>),
         // TODO: Need to allow role creator to unregister it somehow
         visit_unregister_role(Unregister<Role>),
-        visit_unregister_trigger(Unregister<Trigger<TriggeringFilterBox, Executable>>),
+        visit_unregister_trigger(Unregister<Trigger<TriggeringFilterBox>>),
 
         // Visit MintExpr
         visit_mint_asset(Mint<NumericValue, Asset>),
         visit_mint_account_public_key(Mint<PublicKey, Account>),
         visit_mint_account_signature_check_condition(Mint<SignatureCheckCondition, Account>),
-        visit_mint_trigger_repetitions(Mint<u32, Trigger<TriggeringFilterBox, Executable>>),
+        visit_mint_trigger_repetitions(Mint<u32, Trigger<TriggeringFilterBox>>),
 
         // Visit BurnExpr
         visit_burn_account_public_key(Burn<PublicKey, Account>),
@@ -698,9 +698,9 @@ leaf_visitors! {
     visit_unregister_role(Unregister<Role>),
     visit_grant_account_role(Grant<RoleId>),
     visit_revoke_account_role(Revoke<RoleId>),
-    visit_register_trigger(Register<Trigger<TriggeringFilterBox, Executable>>),
-    visit_unregister_trigger(Unregister<Trigger<TriggeringFilterBox, Executable>>),
-    visit_mint_trigger_repetitions(Mint<u32, Trigger<TriggeringFilterBox, Executable>>),
+    visit_register_trigger(Register<Trigger<TriggeringFilterBox>>),
+    visit_unregister_trigger(Unregister<Trigger<TriggeringFilterBox>>),
+    visit_mint_trigger_repetitions(Mint<u32, Trigger<TriggeringFilterBox>>),
     visit_upgrade_validator(Upgrade<Validator>),
     visit_new_parameter(NewParameter),
     visit_set_parameter(SetParameter),
diff --git a/docs/source/references/schema.json b/docs/source/references/schema.json
index b149209bcd6..92fe72ebb24 100644
--- a/docs/source/references/schema.json
+++ b/docs/source/references/schema.json
@@ -179,7 +179,7 @@
       }
     ]
   },
-  "Action<TriggeringFilterBox, Executable>": {
+  "Action<TriggeringFilterBox>": {
     "Struct": [
       {
         "name": "executable",
@@ -203,30 +203,6 @@
       }
     ]
   },
-  "Action<TriggeringFilterBox, OptimizedExecutable>": {
-    "Struct": [
-      {
-        "name": "executable",
-        "type": "OptimizedExecutable"
-      },
-      {
-        "name": "repeats",
-        "type": "Repeats"
-      },
-      {
-        "name": "authority",
-        "type": "AccountId"
-      },
-      {
-        "name": "filter",
-        "type": "TriggeringFilterBox"
-      },
-      {
-        "name": "metadata",
-        "type": "Metadata"
-      }
-    ]
-  },
   "Add": {
     "Struct": [
       {
@@ -2167,7 +2143,6 @@
   "HashOf<MerkleTree<SignedTransaction>>": "Hash",
   "HashOf<SignedBlock>": "Hash",
   "HashOf<SignedTransaction>": "Hash",
-  "HashOf<WasmSmartContract>": "Hash",
   "HashValue": {
     "Enum": [
       {
@@ -2281,7 +2256,7 @@
       {
         "tag": "Trigger",
         "discriminant": 9,
-        "type": "TriggerBox"
+        "type": "Trigger<TriggeringFilterBox>"
       },
       {
         "tag": "Role",
@@ -3073,20 +3048,6 @@
       }
     ]
   },
-  "OptimizedExecutable": {
-    "Enum": [
-      {
-        "tag": "WasmInternalRepr",
-        "discriminant": 0,
-        "type": "WasmInternalRepr"
-      },
-      {
-        "tag": "Instructions",
-        "discriminant": 1,
-        "type": "Vec<InstructionExpr>"
-      }
-    ]
-  },
   "Option<DomainId>": {
     "Option": "DomainId"
   },
@@ -3706,7 +3667,7 @@
       {
         "tag": "Trigger",
         "discriminant": 5,
-        "type": "Trigger<TriggeringFilterBox, Executable>"
+        "type": "Trigger<TriggeringFilterBox>"
       },
       {
         "tag": "Role",
@@ -4337,7 +4298,7 @@
       }
     ]
   },
-  "Trigger<TriggeringFilterBox, Executable>": {
+  "Trigger<TriggeringFilterBox>": {
     "Struct": [
       {
         "name": "id",
@@ -4345,33 +4306,7 @@
       },
       {
         "name": "action",
-        "type": "Action<TriggeringFilterBox, Executable>"
-      }
-    ]
-  },
-  "Trigger<TriggeringFilterBox, OptimizedExecutable>": {
-    "Struct": [
-      {
-        "name": "id",
-        "type": "TriggerId"
-      },
-      {
-        "name": "action",
-        "type": "Action<TriggeringFilterBox, OptimizedExecutable>"
-      }
-    ]
-  },
-  "TriggerBox": {
-    "Enum": [
-      {
-        "tag": "Raw",
-        "discriminant": 0,
-        "type": "Trigger<TriggeringFilterBox, Executable>"
-      },
-      {
-        "tag": "Optimized",
-        "discriminant": 1,
-        "type": "Trigger<TriggeringFilterBox, OptimizedExecutable>"
+        "type": "Action<TriggeringFilterBox>"
       }
     ]
   },
@@ -4845,18 +4780,6 @@
       }
     ]
   },
-  "WasmInternalRepr": {
-    "Struct": [
-      {
-        "name": "serialized",
-        "type": "Vec<u8>"
-      },
-      {
-        "name": "blob_hash",
-        "type": "HashOf<WasmSmartContract>"
-      }
-    ]
-  },
   "WasmSmartContract": "Vec<u8>",
   "Where": {
     "Struct": [
diff --git a/schema/gen/src/lib.rs b/schema/gen/src/lib.rs
index c6f384f62a9..31cfece62c6 100644
--- a/schema/gen/src/lib.rs
+++ b/schema/gen/src/lib.rs
@@ -70,7 +70,7 @@ types!(
     AccountId,
     AccountPermissionChanged,
     AccountRoleChanged,
-    Action<TriggeringFilterBox, Executable>,
+    Action<TriggeringFilterBox>,
     Add,
     Algorithm,
     And,
@@ -354,7 +354,7 @@ types!(
     TransactionRejectionReason,
     TransactionValue,
     TransferExpr,
-    Trigger<TriggeringFilterBox, Executable>,
+    Trigger<TriggeringFilterBox>,
     TriggerCompletedEventFilter,
     TriggerCompletedOutcomeType,
     TriggerEvent,
diff --git a/tools/parity_scale_decoder/build.rs b/tools/parity_scale_decoder/build.rs
index 5d63316f7a7..cbe491c10df 100644
--- a/tools/parity_scale_decoder/build.rs
+++ b/tools/parity_scale_decoder/build.rs
@@ -13,7 +13,7 @@ fn main() {
 
     sample_into_binary_file::<NewDomain>("domain").expect("Failed to encode into domain.bin.");
 
-    sample_into_binary_file::<Trigger<TriggeringFilterBox, Executable>>("trigger")
+    sample_into_binary_file::<Trigger<TriggeringFilterBox>>("trigger")
         .expect("Failed to encode into trigger.bin.");
 }
 
diff --git a/tools/parity_scale_decoder/src/main.rs b/tools/parity_scale_decoder/src/main.rs
index 282634430f8..aa74b4df526 100644
--- a/tools/parity_scale_decoder/src/main.rs
+++ b/tools/parity_scale_decoder/src/main.rs
@@ -269,7 +269,7 @@ mod tests {
         );
         let rose_id = AssetId::new(rose_definition_id, account_id.clone());
         let trigger_id = "mint_rose".parse().expect("Valid");
-        let action = Action::<FilterBox, Executable>::new(
+        let action = Action::<FilterBox>::new(
             vec![MintExpr::new(1_u32, rose_id)],
             Repeats::Indefinitely,
             account_id,
diff --git a/wasm/validator/src/default.rs b/wasm/validator/src/default.rs
index 2ad6a85a32b..9ca88c9b98f 100644
--- a/wasm/validator/src/default.rs
+++ b/wasm/validator/src/default.rs
@@ -1446,7 +1446,7 @@ pub mod trigger {
     pub fn visit_unregister_trigger<V: Validate + ?Sized>(
         validator: &mut V,
         authority: &AccountId,
-        isi: Unregister<Trigger<TriggeringFilterBox, Executable>>,
+        isi: Unregister<Trigger<TriggeringFilterBox>>,
     ) {
         let trigger_id = isi.object_id;
 
@@ -1472,7 +1472,7 @@ pub mod trigger {
     pub fn visit_mint_trigger_repetitions<V: Validate + ?Sized>(
         validator: &mut V,
         authority: &AccountId,
-        isi: Mint<u32, Trigger<TriggeringFilterBox, Executable>>,
+        isi: Mint<u32, Trigger<TriggeringFilterBox>>,
     ) {
         let trigger_id = isi.destination_id;