diff --git a/Cargo.lock b/Cargo.lock
index 5392550e46e..c589a2c65d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1385,6 +1385,17 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "derive-where"
+version = "1.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62d671cc41a825ebabc75757b62d3d168c577f9149b2d49ece1dad1f72119d25"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.75",
+]
+
 [[package]]
 name = "derive_arbitrary"
 version = "1.3.2"
@@ -3135,6 +3146,7 @@ version = "2.0.0-rc.1.0"
 dependencies = [
  "base64 0.22.1",
  "criterion",
+ "derive-where",
  "derive_more",
  "displaydoc",
  "getset",
diff --git a/Cargo.toml b/Cargo.toml
index 740812a3f2a..8f503b36eba 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -102,6 +102,7 @@ async-trait = "0.1.81"
 strum = { version = "0.25.0", default-features = false }
 getset = "0.1.2"
 hex-literal = "0.4.1"
+derive-where = "1.2.7"
 
 rand = { version = "0.8.5", default-features = false, features = ["getrandom", "alloc"] }
 axum = { version = "0.7.5", default-features = false }
diff --git a/crates/iroha/src/query.rs b/crates/iroha/src/query.rs
index 42880b28727..11e9284f40e 100644
--- a/crates/iroha/src/query.rs
+++ b/crates/iroha/src/query.rs
@@ -4,6 +4,7 @@ use std::{collections::HashMap, fmt::Debug};
 
 use eyre::{eyre, Context, Result};
 use http::StatusCode;
+use iroha_data_model::query::QueryOutputBatchBoxTuple;
 use iroha_torii_const::uri as torii_uri;
 use parity_scale_codec::{DecodeAll, Encode};
 use url::Url;
@@ -16,9 +17,8 @@ use crate::{
         query::{
             builder::{QueryBuilder, QueryExecutor},
             parameters::ForwardCursor,
-            predicate::HasPredicateBox,
-            Query, QueryOutput, QueryOutputBatchBox, QueryRequest, QueryResponse, QueryWithParams,
-            SingularQuery, SingularQueryBox, SingularQueryOutputBox,
+            Query, QueryOutput, QueryRequest, QueryResponse, QueryWithParams, SingularQuery,
+            SingularQueryBox, SingularQueryOutputBox,
         },
         ValidationFail,
     },
@@ -158,7 +158,7 @@ impl QueryExecutor for Client {
     fn start_query(
         &self,
         query: QueryWithParams,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<Self::Cursor>), Self::Error> {
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<Self::Cursor>), Self::Error> {
         let request_head = self.get_query_request_head();
 
         let request = QueryRequest::Start(query);
@@ -178,7 +178,7 @@ impl QueryExecutor for Client {
 
     fn continue_query(
         cursor: Self::Cursor,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<Self::Cursor>), Self::Error> {
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<Self::Cursor>), Self::Error> {
         let QueryCursor {
             request_head,
             cursor,
@@ -235,10 +235,7 @@ impl Client {
     }
 
     /// Build an iterable query and return a builder object
-    pub fn query<Q>(
-        &self,
-        query: Q,
-    ) -> QueryBuilder<Self, Q, <<Q as Query>::Item as HasPredicateBox>::PredicateBoxType>
+    pub fn query<Q>(&self, query: Q) -> QueryBuilder<Self, Q, Q::Item>
     where
         Q: Query,
     {
diff --git a/crates/iroha/tests/extra_functional/multiple_blocks_created.rs b/crates/iroha/tests/extra_functional/multiple_blocks_created.rs
index 8dc7a00086c..9e438b45673 100644
--- a/crates/iroha/tests/extra_functional/multiple_blocks_created.rs
+++ b/crates/iroha/tests/extra_functional/multiple_blocks_created.rs
@@ -96,7 +96,7 @@ async fn multiple_blocks_created() -> Result<()> {
             client
                 .query(FindAssets::new())
                 .filter_with(|asset| {
-                    asset.id.account.eq(account_id) & asset.id.definition_id.eq(definition)
+                    asset.id.account.eq(account_id) & asset.id.definition.eq(definition)
                 })
                 .execute_all()
         })
diff --git a/crates/iroha/tests/pagination.rs b/crates/iroha/tests/pagination.rs
index 2c8b40405d9..fe710d21411 100644
--- a/crates/iroha/tests/pagination.rs
+++ b/crates/iroha/tests/pagination.rs
@@ -3,6 +3,7 @@ use iroha::{
     client::Client,
     data_model::{asset::AssetDefinition, prelude::*},
 };
+use iroha_data_model::query::dsl::SelectorTuple;
 use iroha_test_network::*;
 use nonzero_ext::nonzero;
 
@@ -60,7 +61,12 @@ fn fetch_size_should_work() -> Result<()> {
     register_assets(&client)?;
 
     let query = QueryWithParams::new(
-        QueryWithFilter::new(FindAssetsDefinitions::new(), CompoundPredicate::PASS).into(),
+        QueryWithFilter::new(
+            FindAssetsDefinitions::new(),
+            CompoundPredicate::PASS,
+            SelectorTuple::default(),
+        )
+        .into(),
         QueryParams::new(
             Pagination::new(Some(nonzero!(7_u64)), 1),
             Sorting::default(),
diff --git a/crates/iroha/tests/sorting.rs b/crates/iroha/tests/sorting.rs
index a5983b99dc1..802ee8d2582 100644
--- a/crates/iroha/tests/sorting.rs
+++ b/crates/iroha/tests/sorting.rs
@@ -4,10 +4,7 @@ use eyre::{Result, WrapErr as _};
 use iroha::{
     client::QueryResult,
     crypto::KeyPair,
-    data_model::{
-        account::Account, name::Name, prelude::*,
-        query::predicate::predicate_atoms::asset::AssetPredicateBox,
-    },
+    data_model::{account::Account, name::Name, prelude::*},
 };
 use iroha_test_network::*;
 use iroha_test_samples::ALICE_ID;
@@ -24,7 +21,7 @@ fn correct_pagination_assets_after_creating_new_one() {
     let missing_indices = vec![N_ASSETS / 2];
     let pagination = Pagination::new(Some(nonzero!(N_ASSETS as u64 / 3)), N_ASSETS as u64 / 3);
     let xor_filter =
-        AssetPredicateBox::build(|asset| asset.id.definition_id.name.starts_with("xor"));
+        CompoundPredicate::<Asset>::build(|asset| asset.id.definition.name.starts_with("xor"));
 
     let sort_by_metadata_key = "sort".parse::<Name>().expect("Valid");
     let sorting = Sorting::by_metadata_key(sort_by_metadata_key.clone());
@@ -201,7 +198,7 @@ fn correct_sorting_of_entities() {
     let res = test_client
         .query(FindAccounts::new())
         .with_sorting(Sorting::by_metadata_key(sort_by_metadata_key.clone()))
-        .filter_with(|account| account.id.domain_id.eq(domain_id))
+        .filter_with(|account| account.id.domain.eq(domain_id))
         .execute_all()
         .expect("Valid");
 
@@ -339,7 +336,7 @@ fn sort_only_elements_which_have_sorting_key() -> Result<()> {
     let res = test_client
         .query(FindAccounts::new())
         .with_sorting(Sorting::by_metadata_key(sort_by_metadata_key))
-        .filter_with(|account| account.id.domain_id.eq(domain_id))
+        .filter_with(|account| account.id.domain.eq(domain_id))
         .execute_all()
         .wrap_err("Failed to submit request")?;
 
diff --git a/crates/iroha_cli/src/main.rs b/crates/iroha_cli/src/main.rs
index 8e80d366888..2a523bad29d 100644
--- a/crates/iroha_cli/src/main.rs
+++ b/crates/iroha_cli/src/main.rs
@@ -251,12 +251,7 @@ fn submit(
 }
 
 mod filter {
-    use iroha::data_model::query::predicate::{
-        predicate_atoms::{
-            account::AccountPredicateBox, asset::AssetPredicateBox, domain::DomainPredicateBox,
-        },
-        CompoundPredicate,
-    };
+    use iroha::data_model::query::dsl::CompoundPredicate;
     use serde::Deserialize;
 
     use super::*;
@@ -265,32 +260,32 @@ mod filter {
     #[derive(Clone, Debug, clap::Parser)]
     pub struct DomainFilter {
         /// Predicate for filtering given as JSON5 string
-        #[clap(value_parser = parse_json5::<CompoundPredicate<DomainPredicateBox>>)]
-        pub predicate: CompoundPredicate<DomainPredicateBox>,
+        #[clap(value_parser = parse_json5::<CompoundPredicate<Domain>>)]
+        pub predicate: CompoundPredicate<Domain>,
     }
 
     /// Filter for account queries
     #[derive(Clone, Debug, clap::Parser)]
     pub struct AccountFilter {
         /// Predicate for filtering given as JSON5 string
-        #[clap(value_parser = parse_json5::<CompoundPredicate<AccountPredicateBox>>)]
-        pub predicate: CompoundPredicate<AccountPredicateBox>,
+        #[clap(value_parser = parse_json5::<CompoundPredicate<Account>>)]
+        pub predicate: CompoundPredicate<Account>,
     }
 
     /// Filter for asset queries
     #[derive(Clone, Debug, clap::Parser)]
     pub struct AssetFilter {
         /// Predicate for filtering given as JSON5 string
-        #[clap(value_parser = parse_json5::<CompoundPredicate<AssetPredicateBox>>)]
-        pub predicate: CompoundPredicate<AssetPredicateBox>,
+        #[clap(value_parser = parse_json5::<CompoundPredicate<Asset>>)]
+        pub predicate: CompoundPredicate<Asset>,
     }
 
     /// Filter for asset definition queries
     #[derive(Clone, Debug, clap::Parser)]
     pub struct AssetDefinitionFilter {
         /// Predicate for filtering given as JSON5 string
-        #[clap(value_parser = parse_json5::<CompoundPredicate<AssetDefinitionPredicateBox>>)]
-        pub predicate: CompoundPredicate<AssetDefinitionPredicateBox>,
+        #[clap(value_parser = parse_json5::<CompoundPredicate<AssetDefinition>>)]
+        pub predicate: CompoundPredicate<AssetDefinition>,
     }
 
     fn parse_json5<T>(s: &str) -> Result<T, String>
@@ -1219,18 +1214,40 @@ mod json {
                             // we can't really do type-erased iterable queries in a nice way right now...
                             use iroha::data_model::query::builder::QueryExecutor;
 
-                            let (mut first_batch, _remaining_items, mut continue_cursor) =
+                            let (mut accumulated_batch, _remaining_items, mut continue_cursor) =
                                 client.start_query(query)?;
 
                             while let Some(cursor) = continue_cursor {
                                 let (next_batch, _remaining_items, next_continue_cursor) =
                                     <Client as QueryExecutor>::continue_query(cursor)?;
 
-                                first_batch.extend(next_batch);
+                                accumulated_batch.extend(next_batch);
                                 continue_cursor = next_continue_cursor;
                             }
 
-                            context.print_data(&first_batch)?;
+                            // for efficiency reasons iroha encodes query results in a columnar format,
+                            // so we need to transpose the batch to get the format that is more natural for humans
+                            let mut batches = vec![Vec::new(); accumulated_batch.len()];
+                            for batch in accumulated_batch.into_iter() {
+                                // downcast to json and extract the actual array
+                                // dynamic typing is just easier to use here than introducing a bunch of new types only for iroha_cli
+                                let batch = serde_json::to_value(batch)?;
+                                let serde_json::Value::Object(batch) = batch else {
+                                    panic!("Expected the batch serialization to be a JSON object");
+                                };
+                                let (_ty, batch) = batch
+                                    .into_iter()
+                                    .next()
+                                    .expect("Expected the batch to have exactly one key");
+                                let serde_json::Value::Array(batch_vec) = batch else {
+                                    panic!("Expected the batch payload to be a JSON array");
+                                };
+                                for (target, value) in batches.iter_mut().zip(batch_vec) {
+                                    target.push(value);
+                                }
+                            }
+
+                            context.print_data(&batches)?;
                         }
                     }
 
diff --git a/crates/iroha_core/src/query/cursor.rs b/crates/iroha_core/src/query/cursor.rs
index cd572ead5c0..fad98fcb255 100644
--- a/crates/iroha_core/src/query/cursor.rs
+++ b/crates/iroha_core/src/query/cursor.rs
@@ -2,7 +2,13 @@
 
 use std::{fmt::Debug, num::NonZeroU64};
 
-use iroha_data_model::query::QueryOutputBatchBox;
+use iroha_data_model::{
+    prelude::SelectorTuple,
+    query::{
+        dsl::{EvaluateSelector, HasProjection, SelectorMarker},
+        QueryOutputBatchBox, QueryOutputBatchBoxTuple,
+    },
+};
 use parity_scale_codec::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
@@ -25,16 +31,47 @@ pub enum Error {
     Done,
 }
 
+fn evaluate_selector_tuple<T>(
+    batch: Vec<T>,
+    selector: &SelectorTuple<T>,
+) -> QueryOutputBatchBoxTuple
+where
+    T: HasProjection<SelectorMarker, AtomType = ()> + 'static,
+    T::Projection: EvaluateSelector<T>,
+{
+    let mut batch_tuple = Vec::new();
+
+    let mut iter = selector.iter().peekable();
+
+    while let Some(item) = iter.next() {
+        if iter.peek().is_none() {
+            // do not clone the last item
+            batch_tuple.push(item.project(batch.into_iter()));
+            return QueryOutputBatchBoxTuple { tuple: batch_tuple };
+        }
+
+        batch_tuple.push(item.project_clone(batch.iter()));
+    }
+
+    // this should only happen for empty selectors
+    QueryOutputBatchBoxTuple { tuple: batch_tuple }
+}
+
 trait BatchedTrait {
     fn next_batch(
         &mut self,
         cursor: u64,
-    ) -> Result<(QueryOutputBatchBox, Option<NonZeroU64>), Error>;
+    ) -> Result<(QueryOutputBatchBoxTuple, Option<NonZeroU64>), Error>;
     fn remaining(&self) -> u64;
 }
 
-struct BatchedInner<I> {
+struct BatchedInner<I>
+where
+    I: ExactSizeIterator,
+    I::Item: HasProjection<SelectorMarker, AtomType = ()>,
+{
     iter: I,
+    selector: SelectorTuple<I::Item>,
     batch_size: NonZeroU64,
     cursor: Option<u64>,
 }
@@ -42,12 +79,14 @@ struct BatchedInner<I> {
 impl<I> BatchedTrait for BatchedInner<I>
 where
     I: ExactSizeIterator,
+    I::Item: HasProjection<SelectorMarker, AtomType = ()> + 'static,
+    <I::Item as HasProjection<SelectorMarker>>::Projection: EvaluateSelector<I::Item>,
     QueryOutputBatchBox: From<Vec<I::Item>>,
 {
     fn next_batch(
         &mut self,
         cursor: u64,
-    ) -> Result<(QueryOutputBatchBox, Option<NonZeroU64>), Error> {
+    ) -> Result<(QueryOutputBatchBoxTuple, Option<NonZeroU64>), Error> {
         let Some(server_cursor) = self.cursor else {
             // the server is done with the iterator
             return Err(Error::Done);
@@ -76,7 +115,9 @@ where
                     .expect("`u32` should always fit into `usize`"),
             )
             .collect();
-        let batch = batch.into();
+
+        // evaluate the requested projections
+        let batch = evaluate_selector_tuple(batch, &self.selector);
 
         // did we get enough elements to continue?
         if current_batch_size >= expected_batch_size {
@@ -101,27 +142,31 @@ where
     }
 }
 
-/// A query output iterator that combines batching and type erasure.
-pub struct QueryBatchedErasedIterator {
+/// A query output iterator that combines evaluating selectors, batching and type erasure.
+pub struct ErasedQueryIterator {
     inner: Box<dyn BatchedTrait + Send + Sync>,
 }
 
-impl Debug for QueryBatchedErasedIterator {
+impl Debug for ErasedQueryIterator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("QueryBatchedErasedIterator").finish()
     }
 }
 
-impl QueryBatchedErasedIterator {
-    /// Creates a new batched iterator. Boxes the inner iterator to erase its type.
-    pub fn new<I>(iter: I, batch_size: NonZeroU64) -> Self
+impl ErasedQueryIterator {
+    /// Creates a new erased query iterator. Boxes the inner iterator to erase its type.
+    pub fn new<I>(iter: I, selector: SelectorTuple<I::Item>, batch_size: NonZeroU64) -> Self
     where
         I: ExactSizeIterator + Send + Sync + 'static,
+        I::Item: HasProjection<SelectorMarker, AtomType = ()> + 'static,
+        <I::Item as HasProjection<SelectorMarker>>::Projection:
+            EvaluateSelector<I::Item> + Send + Sync,
         QueryOutputBatchBox: From<Vec<I::Item>>,
     {
         Self {
             inner: Box::new(BatchedInner {
                 iter,
+                selector,
                 batch_size,
                 cursor: Some(0),
             }),
@@ -141,7 +186,7 @@ impl QueryBatchedErasedIterator {
     pub fn next_batch(
         &mut self,
         cursor: u64,
-    ) -> Result<(QueryOutputBatchBox, Option<NonZeroU64>), Error> {
+    ) -> Result<(QueryOutputBatchBoxTuple, Option<NonZeroU64>), Error> {
         self.inner.next_batch(cursor)
     }
 
diff --git a/crates/iroha_core/src/query/store.rs b/crates/iroha_core/src/query/store.rs
index 3db0c98e476..6694ce4a333 100644
--- a/crates/iroha_core/src/query/store.rs
+++ b/crates/iroha_core/src/query/store.rs
@@ -13,7 +13,7 @@ use iroha_data_model::{
     query::{
         error::QueryExecutionFail,
         parameters::{ForwardCursor, QueryId},
-        QueryOutput, QueryOutputBatchBox,
+        QueryOutput, QueryOutputBatchBoxTuple,
     },
 };
 use iroha_futures::supervisor::{Child, OnShutdown, ShutdownSignal};
@@ -22,7 +22,7 @@ use parity_scale_codec::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 use tokio::task::JoinHandle;
 
-use super::cursor::{Error as CursorError, QueryBatchedErasedIterator};
+use super::cursor::{ErasedQueryIterator, Error as CursorError};
 
 /// Query service error.
 #[derive(
@@ -66,7 +66,7 @@ impl From<Error> for QueryExecutionFail {
 /// Result type for [`LiveQueryStore`] methods.
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
-type LiveQuery = QueryBatchedErasedIterator;
+type LiveQuery = ErasedQueryIterator;
 
 /// Service which stores queries which might be non fully consumed by a client.
 ///
@@ -156,12 +156,7 @@ impl LiveQueryStore {
         })
     }
 
-    fn insert(
-        &self,
-        query_id: QueryId,
-        live_query: QueryBatchedErasedIterator,
-        authority: AccountId,
-    ) {
+    fn insert(&self, query_id: QueryId, live_query: ErasedQueryIterator, authority: AccountId) {
         *self.queries_per_user.entry(authority.clone()).or_insert(0) += 1;
         let query_info = QueryInfo {
             live_query,
@@ -189,7 +184,7 @@ impl LiveQueryStore {
     fn insert_new_query(
         &self,
         query_id: QueryId,
-        live_query: QueryBatchedErasedIterator,
+        live_query: ErasedQueryIterator,
         authority: AccountId,
     ) -> Result<()> {
         trace!(%query_id, "Inserting new query");
@@ -204,7 +199,7 @@ impl LiveQueryStore {
         &self,
         query_id: QueryId,
         cursor: NonZeroU64,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<NonZeroU64>)> {
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<NonZeroU64>)> {
         trace!(%query_id, "Advancing existing query");
         let QueryInfo {
             mut live_query,
@@ -256,7 +251,7 @@ impl LiveQueryStoreHandle {
     /// - Otherwise throws up query output handling errors.
     pub fn handle_iter_start(
         &self,
-        mut live_query: QueryBatchedErasedIterator,
+        mut live_query: ErasedQueryIterator,
         authority: &AccountId,
     ) -> Result<QueryOutput> {
         let query_id = uuid::Uuid::new_v4().to_string();
@@ -307,7 +302,7 @@ impl LiveQueryStoreHandle {
     }
 
     fn construct_query_response(
-        batch: QueryOutputBatchBox,
+        batch: QueryOutputBatchBoxTuple,
         remaining_items: u64,
         query_id: QueryId,
         cursor: Option<NonZeroU64>,
@@ -327,6 +322,7 @@ impl LiveQueryStoreHandle {
 mod tests {
     use iroha_data_model::{
         permission::Permission,
+        prelude::SelectorTuple,
         query::parameters::{FetchSize, Pagination, QueryParams, Sorting},
     };
     use iroha_primitives::json::Json;
@@ -358,6 +354,7 @@ mod tests {
                 (0..100).map(|_| Permission::new(String::default(), Json::from(false)));
             let query_output = crate::smartcontracts::query::apply_query_postprocessing(
                 query_output,
+                SelectorTuple::default(),
                 &query_params,
             )
             .unwrap();
diff --git a/crates/iroha_core/src/smartcontracts/isi/account.rs b/crates/iroha_core/src/smartcontracts/isi/account.rs
index 914b1311b12..aee01dc458c 100644
--- a/crates/iroha_core/src/smartcontracts/isi/account.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/account.rs
@@ -442,16 +442,7 @@ pub mod query {
     use iroha_data_model::{
         account::Account,
         permission::Permission,
-        query::{
-            error::QueryExecutionFail as Error,
-            predicate::{
-                predicate_atoms::{
-                    account::AccountPredicateBox, permission::PermissionPredicateBox,
-                    role::RoleIdPredicateBox,
-                },
-                CompoundPredicate,
-            },
-        },
+        query::{dsl::CompoundPredicate, error::QueryExecutionFail as Error},
     };
     use iroha_primitives::json::Json;
 
@@ -462,7 +453,7 @@ pub mod query {
         #[metrics(+"find_roles_by_account_id")]
         fn execute(
             self,
-            filter: CompoundPredicate<RoleIdPredicateBox>,
+            filter: CompoundPredicate<RoleId>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = RoleId>, Error> {
             let account_id = &self.id;
@@ -479,7 +470,7 @@ pub mod query {
         #[metrics(+"find_permissions_by_account_id")]
         fn execute(
             self,
-            filter: CompoundPredicate<PermissionPredicateBox>,
+            filter: CompoundPredicate<Permission>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Permission>, Error> {
             let account_id = &self.id;
@@ -495,7 +486,7 @@ pub mod query {
         #[metrics(+"find_accounts")]
         fn execute(
             self,
-            filter: CompoundPredicate<AccountPredicateBox>,
+            filter: CompoundPredicate<Account>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Account>, Error> {
             Ok(state_ro
@@ -524,7 +515,7 @@ pub mod query {
         #[metrics(+"find_accounts_with_asset")]
         fn execute(
             self,
-            filter: CompoundPredicate<AccountPredicateBox>,
+            filter: CompoundPredicate<Account>,
             state_ro: &impl StateReadOnly,
         ) -> std::result::Result<impl Iterator<Item = Account>, Error> {
             let asset_definition_id = self.asset_definition.clone();
diff --git a/crates/iroha_core/src/smartcontracts/isi/asset.rs b/crates/iroha_core/src/smartcontracts/isi/asset.rs
index 9db957022ca..7e06775ccb8 100644
--- a/crates/iroha_core/src/smartcontracts/isi/asset.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/asset.rs
@@ -425,13 +425,7 @@ pub mod query {
     use eyre::Result;
     use iroha_data_model::{
         asset::{Asset, AssetDefinition, AssetValue},
-        query::{
-            error::QueryExecutionFail as Error,
-            predicate::{
-                predicate_atoms::asset::{AssetDefinitionPredicateBox, AssetPredicateBox},
-                CompoundPredicate,
-            },
-        },
+        query::{dsl::CompoundPredicate, error::QueryExecutionFail as Error},
     };
     use iroha_primitives::json::Json;
 
@@ -442,7 +436,7 @@ pub mod query {
         #[metrics(+"find_assets")]
         fn execute(
             self,
-            filter: CompoundPredicate<AssetPredicateBox>,
+            filter: CompoundPredicate<Asset>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Asset>, Error> {
             Ok(state_ro
@@ -456,7 +450,7 @@ pub mod query {
         #[metrics(+"find_asset_definitions")]
         fn execute(
             self,
-            filter: CompoundPredicate<AssetDefinitionPredicateBox>,
+            filter: CompoundPredicate<AssetDefinition>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = AssetDefinition>, Error> {
             Ok(state_ro
diff --git a/crates/iroha_core/src/smartcontracts/isi/block.rs b/crates/iroha_core/src/smartcontracts/isi/block.rs
index c398c7a7378..341e35fcb19 100644
--- a/crates/iroha_core/src/smartcontracts/isi/block.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/block.rs
@@ -1,11 +1,8 @@
 //! This module contains trait implementations related to block queries
 use eyre::Result;
-use iroha_data_model::query::{
-    error::QueryExecutionFail,
-    predicate::{
-        predicate_atoms::block::{BlockHeaderPredicateBox, SignedBlockPredicateBox},
-        CompoundPredicate,
-    },
+use iroha_data_model::{
+    block::{BlockHeader, SignedBlock},
+    query::{dsl::CompoundPredicate, error::QueryExecutionFail},
 };
 use iroha_telemetry::metrics;
 use nonzero_ext::nonzero;
@@ -17,7 +14,7 @@ impl ValidQuery for FindBlocks {
     #[metrics(+"find_blocks")]
     fn execute(
         self,
-        filter: CompoundPredicate<SignedBlockPredicateBox>,
+        filter: CompoundPredicate<SignedBlock>,
         state_ro: &impl StateReadOnly,
     ) -> Result<impl Iterator<Item = Self::Item>, QueryExecutionFail> {
         Ok(state_ro
@@ -32,7 +29,7 @@ impl ValidQuery for FindBlockHeaders {
     #[metrics(+"find_block_headers")]
     fn execute(
         self,
-        filter: CompoundPredicate<BlockHeaderPredicateBox>,
+        filter: CompoundPredicate<BlockHeader>,
         state_ro: &impl StateReadOnly,
     ) -> Result<impl Iterator<Item = Self::Item>, QueryExecutionFail> {
         Ok(state_ro
diff --git a/crates/iroha_core/src/smartcontracts/isi/domain.rs b/crates/iroha_core/src/smartcontracts/isi/domain.rs
index 7131c4ec2f2..5f579b195e1 100644
--- a/crates/iroha_core/src/smartcontracts/isi/domain.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/domain.rs
@@ -383,10 +383,7 @@ pub mod query {
     use eyre::Result;
     use iroha_data_model::{
         domain::Domain,
-        query::{
-            error::QueryExecutionFail as Error,
-            predicate::{predicate_atoms::domain::DomainPredicateBox, CompoundPredicate},
-        },
+        query::{dsl::CompoundPredicate, error::QueryExecutionFail},
     };
     use iroha_primitives::json::Json;
 
@@ -397,9 +394,9 @@ pub mod query {
         #[metrics(+"find_domains")]
         fn execute(
             self,
-            filter: CompoundPredicate<DomainPredicateBox>,
+            filter: CompoundPredicate<Domain>,
             state_ro: &impl StateReadOnly,
-        ) -> std::result::Result<impl Iterator<Item = Domain>, Error> {
+        ) -> std::result::Result<impl Iterator<Item = Domain>, QueryExecutionFail> {
             Ok(state_ro
                 .world()
                 .domains_iter()
@@ -410,7 +407,7 @@ pub mod query {
 
     impl ValidSingularQuery for FindDomainMetadata {
         #[metrics(+"find_domain_key_value_by_id_and_key")]
-        fn execute(&self, state_ro: &impl StateReadOnly) -> Result<Json, Error> {
+        fn execute(&self, state_ro: &impl StateReadOnly) -> Result<Json, QueryExecutionFail> {
             let id = &self.id;
             let key = &self.key;
             iroha_logger::trace!(%id, %key);
@@ -424,7 +421,7 @@ pub mod query {
 
     impl ValidSingularQuery for FindAssetDefinitionMetadata {
         #[metrics(+"find_asset_definition_key_value_by_id_and_key")]
-        fn execute(&self, state_ro: &impl StateReadOnly) -> Result<Json, Error> {
+        fn execute(&self, state_ro: &impl StateReadOnly) -> Result<Json, QueryExecutionFail> {
             let id = &self.id;
             let key = &self.key;
             iroha_logger::trace!(%id, %key);
diff --git a/crates/iroha_core/src/smartcontracts/isi/query.rs b/crates/iroha_core/src/smartcontracts/isi/query.rs
index 8eb0263ef43..72f28da4d72 100644
--- a/crates/iroha_core/src/smartcontracts/isi/query.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/query.rs
@@ -6,17 +6,17 @@ use eyre::Result;
 use iroha_data_model::{
     prelude::*,
     query::{
-        error::QueryExecutionFail as Error, parameters::QueryParams, CommittedTransaction,
-        QueryBox, QueryOutputBatchBox, QueryRequest, QueryRequestWithAuthority, QueryResponse,
-        SingularQueryBox, SingularQueryOutputBox,
+        dsl::{EvaluateSelector, HasProjection, SelectorMarker},
+        error::QueryExecutionFail as Error,
+        parameters::QueryParams,
+        CommittedTransaction, QueryBox, QueryOutputBatchBox, QueryRequest,
+        QueryRequestWithAuthority, QueryResponse, SingularQueryBox, SingularQueryOutputBox,
     },
 };
 
 use crate::{
     prelude::ValidSingularQuery,
-    query::{
-        cursor::QueryBatchedErasedIterator, pagination::Paginate as _, store::LiveQueryStoreHandle,
-    },
+    query::{cursor::ErasedQueryIterator, pagination::Paginate as _, store::LiveQueryStoreHandle},
     smartcontracts::{wasm, ValidQuery},
     state::{StateReadOnly, WorldReadOnly},
 };
@@ -117,14 +117,17 @@ impl SortableQueryOutput for iroha_data_model::block::BlockHeader {
 /// Returns an error if the fetch size is too big
 pub fn apply_query_postprocessing<I>(
     iter: I,
+    selector: SelectorTuple<I::Item>,
     &QueryParams {
         pagination,
         ref sorting,
         fetch_size,
     }: &QueryParams,
-) -> Result<QueryBatchedErasedIterator, Error>
+) -> Result<ErasedQueryIterator, Error>
 where
     I: Iterator<Item: SortableQueryOutput + Send + Sync + 'static>,
+    I::Item: HasProjection<SelectorMarker, AtomType = ()> + 'static,
+    <I::Item as HasProjection<SelectorMarker>>::Projection: EvaluateSelector<I::Item> + Send + Sync,
     QueryOutputBatchBox: From<Vec<I::Item>>,
 {
     // validate the fetch (aka batch) size
@@ -153,8 +156,9 @@ where
             },
         );
 
-        QueryBatchedErasedIterator::new(
+        ErasedQueryIterator::new(
             pairs.into_iter().map(|(_, val)| val).paginate(pagination),
+            selector,
             fetch_size,
         )
     } else {
@@ -169,7 +173,7 @@ where
             // TODO: investigate this
             .collect::<Vec<_>>();
 
-        QueryBatchedErasedIterator::new(output.into_iter(), fetch_size)
+        ErasedQueryIterator::new(output.into_iter(), selector, fetch_size)
     };
 
     Ok(output)
@@ -265,62 +269,77 @@ impl ValidQueryRequest {
                     // dispatch on a concrete query type, erasing the type with `QueryBatchedErasedIterator` in the end
                     QueryBox::FindDomains(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindAccounts(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindAssets(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindAssetsDefinitions(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindRoles(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindRoleIds(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindPermissionsByAccountId(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindRolesByAccountId(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindAccountsWithAsset(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindPeers(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindActiveTriggerIds(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindTriggers(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindTransactions(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindBlocks(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                     QueryBox::FindBlockHeaders(q) => apply_query_postprocessing(
                         ValidQuery::execute(q.query, q.predicate, state)?,
+                        q.selector,
                         &iter_query.params,
                     )?,
                 };
@@ -339,7 +358,7 @@ impl ValidQueryRequest {
 #[cfg(test)]
 mod tests {
     use iroha_crypto::{Hash, KeyPair};
-    use iroha_data_model::query::predicate::CompoundPredicate;
+    use iroha_data_model::{block::BlockHeader, query::dsl::CompoundPredicate};
     use iroha_primitives::json::Json;
     use iroha_test_samples::{gen_account_in, ALICE_ID, ALICE_KEYPAIR};
     use nonzero_ext::nonzero;
@@ -539,7 +558,7 @@ mod tests {
         assert_eq!(
             FindBlockHeaders::new()
                 .execute(
-                    BlockHeaderPredicateBox::build(|header| header.hash.eq(block.hash())),
+                    CompoundPredicate::<BlockHeader>::build(|header| header.hash.eq(block.hash())),
                     &state_view,
                 )
                 .expect("Query execution should not fail")
@@ -550,7 +569,7 @@ mod tests {
         assert!(
             FindBlockHeaders::new()
                 .execute(
-                    BlockHeaderPredicateBox::build(|header| {
+                    CompoundPredicate::<BlockHeader>::build(|header| {
                         header
                             .hash
                             .eq(HashOf::from_untyped_unchecked(Hash::new([42])))
@@ -634,7 +653,7 @@ mod tests {
 
         let not_found = FindTransactions::new()
             .execute(
-                CommittedTransactionPredicateBox::build(|tx| tx.value.hash.eq(wrong_hash)),
+                CompoundPredicate::<CommittedTransaction>::build(|tx| tx.value.hash.eq(wrong_hash)),
                 &state_view,
             )
             .expect("Query execution should not fail")
@@ -643,7 +662,7 @@ mod tests {
 
         let found_accepted = FindTransactions::new()
             .execute(
-                CommittedTransactionPredicateBox::build(|tx| {
+                CompoundPredicate::<CommittedTransaction>::build(|tx| {
                     tx.value.hash.eq(va_tx.as_ref().hash())
                 }),
                 &state_view,
diff --git a/crates/iroha_core/src/smartcontracts/isi/triggers/mod.rs b/crates/iroha_core/src/smartcontracts/isi/triggers/mod.rs
index 411076e5a56..ed1c9d70785 100644
--- a/crates/iroha_core/src/smartcontracts/isi/triggers/mod.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/triggers/mod.rs
@@ -311,9 +311,7 @@ pub mod query {
     //! Queries associated to triggers.
     use iroha_data_model::{
         query::{
-            error::QueryExecutionFail as Error,
-            predicate::{predicate_atoms::trigger::TriggerIdPredicateBox, CompoundPredicate},
-            trigger::FindTriggers,
+            dsl::CompoundPredicate, error::QueryExecutionFail as Error, trigger::FindTriggers,
         },
         trigger::{Trigger, TriggerId},
     };
@@ -330,7 +328,7 @@ pub mod query {
         #[metrics(+"find_active_triggers")]
         fn execute(
             self,
-            filter: CompoundPredicate<TriggerIdPredicateBox>,
+            filter: CompoundPredicate<TriggerId>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = TriggerId>, Error> {
             Ok(state_ro
@@ -346,7 +344,7 @@ pub mod query {
         #[metrics(+"find_triggers")]
         fn execute(
             self,
-            filter: CompoundPredicate<TriggerPredicateBox>,
+            filter: CompoundPredicate<Trigger>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Self::Item>, Error> {
             let triggers = state_ro.world().triggers();
diff --git a/crates/iroha_core/src/smartcontracts/isi/tx.rs b/crates/iroha_core/src/smartcontracts/isi/tx.rs
index 8464b3c2a10..1e94062e48e 100644
--- a/crates/iroha_core/src/smartcontracts/isi/tx.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/tx.rs
@@ -7,11 +7,7 @@ use iroha_crypto::HashOf;
 use iroha_data_model::{
     block::{BlockHeader, SignedBlock},
     prelude::*,
-    query::{
-        error::QueryExecutionFail,
-        predicate::{predicate_atoms::block::CommittedTransactionPredicateBox, CompoundPredicate},
-        CommittedTransaction,
-    },
+    query::{dsl::CompoundPredicate, error::QueryExecutionFail, CommittedTransaction},
     transaction::error::TransactionRejectionReason,
 };
 use iroha_telemetry::metrics;
@@ -65,7 +61,7 @@ impl ValidQuery for FindTransactions {
     #[metrics(+"find_transactions")]
     fn execute(
         self,
-        filter: CompoundPredicate<CommittedTransactionPredicateBox>,
+        filter: CompoundPredicate<CommittedTransaction>,
         state_ro: &impl StateReadOnly,
     ) -> Result<impl Iterator<Item = Self::Item>, QueryExecutionFail> {
         Ok(state_ro
diff --git a/crates/iroha_core/src/smartcontracts/isi/world.rs b/crates/iroha_core/src/smartcontracts/isi/world.rs
index 38d44dd6868..b5da5a99c82 100644
--- a/crates/iroha_core/src/smartcontracts/isi/world.rs
+++ b/crates/iroha_core/src/smartcontracts/isi/world.rs
@@ -451,16 +451,7 @@ pub mod query {
     use iroha_data_model::{
         parameter::Parameters,
         prelude::*,
-        query::{
-            error::QueryExecutionFail as Error,
-            predicate::{
-                predicate_atoms::{
-                    peer::PeerPredicateBox,
-                    role::{RoleIdPredicateBox, RolePredicateBox},
-                },
-                CompoundPredicate,
-            },
-        },
+        query::{dsl::CompoundPredicate, error::QueryExecutionFail as Error},
         role::Role,
     };
 
@@ -471,7 +462,7 @@ pub mod query {
         #[metrics(+"find_roles")]
         fn execute(
             self,
-            filter: CompoundPredicate<RolePredicateBox>,
+            filter: CompoundPredicate<Role>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Self::Item>, Error> {
             Ok(state_ro
@@ -488,7 +479,7 @@ pub mod query {
         #[metrics(+"find_role_ids")]
         fn execute(
             self,
-            filter: CompoundPredicate<RoleIdPredicateBox>,
+            filter: CompoundPredicate<RoleId>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Self::Item>, Error> {
             Ok(state_ro
@@ -506,7 +497,7 @@ pub mod query {
         #[metrics(+"find_peers")]
         fn execute(
             self,
-            filter: CompoundPredicate<PeerPredicateBox>,
+            filter: CompoundPredicate<PeerId>,
             state_ro: &impl StateReadOnly,
         ) -> Result<impl Iterator<Item = Self::Item>, Error> {
             Ok(state_ro
diff --git a/crates/iroha_core/src/smartcontracts/mod.rs b/crates/iroha_core/src/smartcontracts/mod.rs
index 009ba6b1157..4a2ca1aeb92 100644
--- a/crates/iroha_core/src/smartcontracts/mod.rs
+++ b/crates/iroha_core/src/smartcontracts/mod.rs
@@ -10,10 +10,7 @@ pub mod wasm;
 use iroha_data_model::{
     isi::error::InstructionExecutionError as Error,
     prelude::*,
-    query::{
-        error::QueryExecutionFail,
-        predicate::{CompoundPredicate, HasPredicateBox},
-    },
+    query::{dsl::CompoundPredicate, error::QueryExecutionFail},
 };
 pub use isi::*;
 
@@ -33,10 +30,7 @@ pub trait Execute {
 }
 
 /// This trait defines how an Iroha Iterable query is executed.
-pub trait ValidQuery: iroha_data_model::query::Query
-where
-    Self::Item: HasPredicateBox,
-{
+pub trait ValidQuery: iroha_data_model::query::Query {
     /// Execute a query on a read-only state.
     ///
     /// The filter is deliberately passed to the query implementation,
@@ -46,7 +40,7 @@ where
     /// Concrete to each implementer
     fn execute(
         self,
-        filter: CompoundPredicate<<Self::Item as HasPredicateBox>::PredicateBoxType>,
+        filter: CompoundPredicate<Self::Item>,
         state_ro: &impl StateReadOnly,
     ) -> Result<impl Iterator<Item = Self::Item>, QueryExecutionFail>;
 }
diff --git a/crates/iroha_core/src/sumeragi/main_loop.rs b/crates/iroha_core/src/sumeragi/main_loop.rs
index f94df318ed5..ac3a05d813a 100644
--- a/crates/iroha_core/src/sumeragi/main_loop.rs
+++ b/crates/iroha_core/src/sumeragi/main_loop.rs
@@ -312,10 +312,20 @@ impl Sumeragi {
         .unpack(|e| self.send_event(e))
         .expect("Genesis invalid");
 
-        assert!(
-            genesis.as_ref().errors().next().is_none(),
-            "Genesis contains invalid transactions"
-        );
+        if genesis.as_ref().errors().next().is_some() {
+            let errors = genesis
+                .as_ref()
+                .errors()
+                .map(|(&transaction_index, rejection_reason)| {
+                    format!(
+                        "===\nTx {transaction_index}:\n{:?}",
+                        eyre::Error::new(rejection_reason.clone())
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join("\n");
+            panic!("Genesis contains invalid transactions:\n{}", errors);
+        }
 
         // NOTE: By this time genesis block is executed and list of trusted peers is updated
         self.topology = Topology::new(state_block.world.peers.clone());
diff --git a/crates/iroha_data_model/Cargo.toml b/crates/iroha_data_model/Cargo.toml
index c10264d929f..2e074fc9bbb 100644
--- a/crates/iroha_data_model/Cargo.toml
+++ b/crates/iroha_data_model/Cargo.toml
@@ -44,6 +44,7 @@ serde_json = { workspace = true }
 thiserror = { workspace = true, optional = true }
 displaydoc = { workspace = true }
 getset = { workspace = true }
+derive-where = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
 base64 = { workspace = true, features = ["alloc"] }
 nonzero_ext = { workspace = true }
diff --git a/crates/iroha_data_model/src/query/builder/batch_downcast.rs b/crates/iroha_data_model/src/query/builder/batch_downcast.rs
new file mode 100644
index 00000000000..230d023dfeb
--- /dev/null
+++ b/crates/iroha_data_model/src/query/builder/batch_downcast.rs
@@ -0,0 +1,154 @@
+#[cfg(not(feature = "std"))]
+use alloc::vec::{self, Vec};
+#[cfg(feature = "std")]
+use std::vec;
+
+use crate::query::{QueryOutputBatchBox, QueryOutputBatchBoxTuple};
+
+#[derive(Debug)]
+pub struct TypedBatchIterUntupled<T> {
+    t: vec::IntoIter<T>,
+}
+
+impl<T> Iterator for TypedBatchIterUntupled<T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.t.next()
+    }
+}
+
+impl<T> ExactSizeIterator for TypedBatchIterUntupled<T> {
+    fn len(&self) -> usize {
+        self.t.len()
+    }
+}
+
+#[derive(Debug, Copy, Clone, displaydoc::Display)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+pub enum TypedBatchDowncastError {
+    /// Not enough slices in the tuple
+    NotEnoughSlices,
+    /// Too many slices in the tuple
+    TooManySlices,
+    /// Wrong type at index {0}
+    WrongType(usize),
+}
+
+pub trait HasTypedBatchIter {
+    type TypedBatchIter: Iterator<Item = Self> + ExactSizeIterator;
+    fn downcast(
+        erased_batch: QueryOutputBatchBoxTuple,
+    ) -> Result<Self::TypedBatchIter, TypedBatchDowncastError>;
+}
+
+impl<T> HasTypedBatchIter for T
+where
+    Vec<T>: TryFrom<QueryOutputBatchBox>,
+{
+    type TypedBatchIter = TypedBatchIterUntupled<T>;
+    fn downcast(
+        erased_batch_tuple: QueryOutputBatchBoxTuple,
+    ) -> Result<Self::TypedBatchIter, TypedBatchDowncastError> {
+        let mut iter = erased_batch_tuple.tuple.into_iter();
+        let t1 = iter
+            .next()
+            .ok_or(TypedBatchDowncastError::NotEnoughSlices)?;
+        if iter.next().is_some() {
+            return Err(TypedBatchDowncastError::TooManySlices);
+        }
+
+        let t1 = <Vec<T> as TryFrom<QueryOutputBatchBox>>::try_from(t1)
+            .ok()
+            .ok_or(TypedBatchDowncastError::WrongType(0))?
+            .into_iter();
+
+        Ok(TypedBatchIterUntupled { t: t1 })
+    }
+}
+
+macro_rules! typed_batch_tuple {
+    (
+        $(
+            $name:ident($($ty_name:ident: $ty:ident),+);
+        )*
+    ) => {
+        $(
+            #[derive(Debug)]
+            pub struct $name<$($ty),+> {
+                $($ty_name: vec::IntoIter<$ty>),+
+            }
+
+            impl<$($ty),+> Iterator for $name<$($ty),+> {
+                type Item = ($($ty,)+);
+                #[allow(unreachable_patterns)] // for batch size the panic will be unreachable. this is fine
+                fn next(&mut self) -> Option<Self::Item> {
+                    $(
+                        let $ty_name = self.$ty_name.next();
+                    )+
+
+                    match ($($ty_name,)+) {
+                        ( $(Some($ty_name),)+ ) => Some(($($ty_name,)+)),
+                        ( $(None::<$ty>,)* ) => None,
+                        _ => panic!("BUG: TypedBatch length mismatch"),
+                    }
+                }
+            }
+
+            impl<$($ty),+> ExactSizeIterator for $name<$($ty),+> {
+                #[allow(unreachable_code)]
+                fn len(&self) -> usize {
+                    // the length of all the iterators in the batch tuple should be the same
+                    // HACK: get the length of the first iterator, making the code for other branches unreachable
+                    $(return self.$ty_name.len();)+
+                }
+            }
+
+            impl<$($ty),+> HasTypedBatchIter for ($($ty,)+)
+            where
+                $(Vec<$ty>: TryFrom<QueryOutputBatchBox>),+
+            {
+                type TypedBatchIter = $name<$($ty),+>;
+                #[expect(unused_assignments)] // the last increment of `index` will be unreachable. this is fine
+                fn downcast(
+                    erased_batch: QueryOutputBatchBoxTuple,
+                ) -> Result<Self::TypedBatchIter, TypedBatchDowncastError> {
+                    let mut iter = erased_batch.tuple.into_iter();
+                    $(
+                        let $ty_name = iter
+                            .next()
+                            .ok_or(TypedBatchDowncastError::NotEnoughSlices)?;
+                    )+
+                    if iter.next().is_some() {
+                        return Err(TypedBatchDowncastError::TooManySlices);
+                    }
+
+                    let mut index = 0;
+                    $(
+                        let $ty_name = <Vec<$ty> as TryFrom<QueryOutputBatchBox>>::try_from($ty_name)
+                            .ok()
+                            .ok_or(TypedBatchDowncastError::WrongType(index))?
+                            .into_iter();
+                        index += 1;
+                    )+
+
+                    Ok($name {
+                        $($ty_name),+
+                    })
+                }
+            }
+        )*
+    };
+}
+
+typed_batch_tuple! {
+    TypedBatch1(t1: T1);
+    TypedBatch2(t1: T1, t2: T2);
+    TypedBatch3(t1: T1, t2: T2, t3: T3);
+    TypedBatch4(t1: T1, t2: T2, t3: T3, t4: T4);
+    TypedBatch5(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5);
+    TypedBatch6(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6);
+    TypedBatch7(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7);
+    TypedBatch8(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8);
+    // who needs more than 8 values in their query, right?
+}
diff --git a/crates/iroha_data_model/src/query/builder/iter.rs b/crates/iroha_data_model/src/query/builder/iter.rs
new file mode 100644
index 00000000000..fc72d6932fb
--- /dev/null
+++ b/crates/iroha_data_model/src/query/builder/iter.rs
@@ -0,0 +1,85 @@
+use crate::query::{
+    builder::{
+        batch_downcast::{HasTypedBatchIter, TypedBatchDowncastError},
+        QueryExecutor,
+    },
+    QueryOutputBatchBoxTuple,
+};
+
+/// An iterator over results of an iterable query.
+#[derive(Debug)]
+pub struct QueryIterator<E: QueryExecutor, T: HasTypedBatchIter> {
+    current_batch_iter: T::TypedBatchIter,
+    remaining_items: u64,
+    continue_cursor: Option<E::Cursor>,
+}
+
+impl<E, T> QueryIterator<E, T>
+where
+    E: QueryExecutor,
+    T: HasTypedBatchIter,
+{
+    /// Create a new iterator over iterable query results.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the type of the batch does not match the expected type `T`.
+    pub fn new(
+        first_batch: QueryOutputBatchBoxTuple,
+        remaining_items: u64,
+        continue_cursor: Option<E::Cursor>,
+    ) -> Result<Self, TypedBatchDowncastError> {
+        let batch_iter = T::downcast(first_batch)?;
+
+        Ok(Self {
+            current_batch_iter: batch_iter,
+            remaining_items,
+            continue_cursor,
+        })
+    }
+}
+
+impl<E, T> Iterator for QueryIterator<E, T>
+where
+    E: QueryExecutor,
+    T: HasTypedBatchIter,
+{
+    type Item = Result<T, E::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // if we haven't exhausted the current batch yet - return it
+        if let Some(item) = self.current_batch_iter.next() {
+            return Some(Ok(item));
+        }
+
+        // no cursor means the query result is exhausted or an error occurred on one of the previous iterations
+        let cursor = self.continue_cursor.take()?;
+
+        // get a next batch from iroha
+        let (batch, remaining_items, cursor) = match E::continue_query(cursor) {
+            Ok(r) => r,
+            Err(e) => return Some(Err(e)),
+        };
+        self.continue_cursor = cursor;
+
+        // downcast the batch to the expected type
+        // we've already downcast the first batch to the expected type, so if iroha returns a different type here, it surely is a bug
+        let batch_iter =
+            T::downcast(batch).expect("BUG: iroha returned unexpected type in iterable query");
+
+        self.current_batch_iter = batch_iter;
+        self.remaining_items = remaining_items;
+
+        self.next()
+    }
+}
+
+impl<E, T> ExactSizeIterator for QueryIterator<E, T>
+where
+    E: QueryExecutor,
+    T: HasTypedBatchIter,
+{
+    fn len(&self) -> usize {
+        self.current_batch_iter.len() + self.remaining_items as usize
+    }
+}
diff --git a/crates/iroha_data_model/src/query/builder.rs b/crates/iroha_data_model/src/query/builder/mod.rs
similarity index 58%
rename from crates/iroha_data_model/src/query/builder.rs
rename to crates/iroha_data_model/src/query/builder/mod.rs
index bafe5e1df1d..71d752c6300 100644
--- a/crates/iroha_data_model/src/query/builder.rs
+++ b/crates/iroha_data_model/src/query/builder/mod.rs
@@ -1,18 +1,26 @@
 //! Contains common types and traits to facilitate building and sending queries, either from the client or from smart contracts.
 
+mod batch_downcast;
+mod iter;
+
 #[cfg(not(feature = "std"))]
-use alloc::vec::{self, Vec};
-#[cfg(feature = "std")]
-use std::vec;
+use alloc::vec::Vec;
+use core::marker::PhantomData;
 
+use derive_where::derive_where;
+pub use iter::QueryIterator;
 use parity_scale_codec::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
 use crate::query::{
+    builder::batch_downcast::HasTypedBatchIter,
+    dsl::{
+        BaseProjector, CompoundPredicate, HasPrototype, IntoSelectorTuple, PredicateMarker,
+        SelectorMarker, SelectorTuple,
+    },
     parameters::{FetchSize, Pagination, QueryParams, Sorting},
-    predicate::{projectors, AstPredicate, CompoundPredicate, HasPredicateBox, HasPrototype},
-    Query, QueryBox, QueryOutputBatchBox, QueryWithFilter, QueryWithFilterFor, QueryWithParams,
-    SingularQueryBox, SingularQueryOutputBox,
+    Query, QueryBox, QueryOutputBatchBoxTuple, QueryWithFilter, QueryWithParams, SingularQueryBox,
+    SingularQueryOutputBox,
 };
 
 /// A trait abstracting away concrete backend for executing queries against iroha.
@@ -42,7 +50,7 @@ pub trait QueryExecutor {
     fn start_query(
         &self,
         query: QueryWithParams,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<Self::Cursor>), Self::Error>;
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<Self::Cursor>), Self::Error>;
 
     /// Continues an iterable query from the given cursor and returns the next batch of results, the remaining number of results and a cursor to continue the query.
     ///
@@ -51,88 +59,7 @@ pub trait QueryExecutor {
     /// Returns an error if the query execution fails.
     fn continue_query(
         cursor: Self::Cursor,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<Self::Cursor>), Self::Error>;
-}
-
-/// An iterator over results of an iterable query.
-#[derive(Debug)]
-pub struct QueryIterator<E: QueryExecutor, T> {
-    current_batch_iter: vec::IntoIter<T>,
-    remaining_items: u64,
-    continue_cursor: Option<E::Cursor>,
-}
-
-impl<E, T> QueryIterator<E, T>
-where
-    E: QueryExecutor,
-    Vec<T>: TryFrom<QueryOutputBatchBox>,
-{
-    /// Create a new iterator over iterable query results.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the type of the batch does not match the expected type `T`.
-    pub fn new(
-        first_batch: QueryOutputBatchBox,
-        remaining_items: u64,
-        continue_cursor: Option<E::Cursor>,
-    ) -> Result<Self, <Vec<T> as TryFrom<QueryOutputBatchBox>>::Error> {
-        let batch: Vec<T> = first_batch.try_into()?;
-
-        Ok(Self {
-            current_batch_iter: batch.into_iter(),
-            remaining_items,
-            continue_cursor,
-        })
-    }
-}
-
-impl<E, T> Iterator for QueryIterator<E, T>
-where
-    E: QueryExecutor,
-    Vec<T>: TryFrom<QueryOutputBatchBox>,
-    <Vec<T> as TryFrom<QueryOutputBatchBox>>::Error: core::fmt::Debug,
-{
-    type Item = Result<T, E::Error>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // if we haven't exhausted the current batch yet - return it
-        if let Some(item) = self.current_batch_iter.next() {
-            return Some(Ok(item));
-        }
-
-        // no cursor means the query result is exhausted or an error occurred on one of the previous iterations
-        let cursor = self.continue_cursor.take()?;
-
-        // get a next batch from iroha
-        let (batch, remaining_items, cursor) = match E::continue_query(cursor) {
-            Ok(r) => r,
-            Err(e) => return Some(Err(e)),
-        };
-        self.continue_cursor = cursor;
-
-        // downcast the batch to the expected type
-        // we've already downcast the first batch to the expected type, so if iroha returns a different type here, it surely is a bug
-        let batch: Vec<T> = batch
-            .try_into()
-            .expect("BUG: iroha returned unexpected type in iterable query");
-
-        self.current_batch_iter = batch.into_iter();
-        self.remaining_items = remaining_items;
-
-        self.next()
-    }
-}
-
-impl<E, T> ExactSizeIterator for QueryIterator<E, T>
-where
-    E: QueryExecutor,
-    Vec<T>: TryFrom<QueryOutputBatchBox>,
-    <Vec<T> as TryFrom<QueryOutputBatchBox>>::Error: core::fmt::Debug,
-{
-    fn len(&self) -> usize {
-        self.current_batch_iter.len() + self.remaining_items as usize
-    }
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<Self::Cursor>), Self::Error>;
 }
 
 /// An error that can occur when constraining the number of results of an iterable query to one.
@@ -169,19 +96,25 @@ impl<E> From<E> for SingleQueryError<E> {
 }
 
 /// Struct that simplifies construction of an iterable query.
-pub struct QueryBuilder<'e, E, Q, P> {
+#[derive_where(Clone; Q, CompoundPredicate<Q::Item>, SelectorTuple<Q::Item>)]
+pub struct QueryBuilder<'e, E, Q, T>
+where
+    Q: Query,
+{
     query_executor: &'e E,
     query: Q,
-    filter: CompoundPredicate<P>,
+    filter: CompoundPredicate<Q::Item>,
+    selector: SelectorTuple<Q::Item>,
     pagination: Pagination,
     sorting: Sorting,
     fetch_size: FetchSize,
+    // NOTE: T is a phantom type used to denote the selected tuple in `selector`
+    phantom: PhantomData<T>,
 }
 
-impl<'a, E, Q, P> QueryBuilder<'a, E, Q, P>
+impl<'a, E, Q> QueryBuilder<'a, E, Q, Q::Item>
 where
     Q: Query,
-    Q::Item: HasPredicateBox<PredicateBoxType = P>,
 {
     /// Create a new iterable query builder for a given backend and query.
     pub fn new(query_executor: &'a E, query: Q) -> Self {
@@ -189,19 +122,24 @@ where
             query_executor,
             query,
             filter: CompoundPredicate::PASS,
+            selector: SelectorTuple::default(),
             pagination: Pagination::default(),
             sorting: Sorting::default(),
             fetch_size: FetchSize::default(),
+            phantom: PhantomData,
         }
     }
 }
 
-impl<E, Q, P> QueryBuilder<'_, E, Q, P> {
+impl<'a, E, Q, T> QueryBuilder<'a, E, Q, T>
+where
+    Q: Query,
+{
     /// Only return results that match the given predicate.
     ///
     /// If multiple filters are added, they are combined with a logical AND.
     #[must_use]
-    pub fn filter(self, filter: CompoundPredicate<P>) -> Self {
+    pub fn filter(self, filter: CompoundPredicate<Q::Item>) -> Self {
         Self {
             filter: self.filter.and(filter),
             ..self
@@ -212,15 +150,54 @@ impl<E, Q, P> QueryBuilder<'_, E, Q, P> {
     ///
     /// If multiple filters are added, they are combined with a logical AND.
     #[must_use]
-    pub fn filter_with<B, O>(self, predicate_builder: B) -> Self
+    pub fn filter_with<B>(self, predicate_builder: B) -> Self
     where
-        P: HasPrototype,
-        B: FnOnce(P::Prototype<projectors::BaseProjector<P>>) -> O,
-        O: AstPredicate<P>,
+        Q::Item: HasPrototype,
+        B: FnOnce(
+            <Q::Item as HasPrototype>::Prototype<
+                PredicateMarker,
+                BaseProjector<PredicateMarker, Q::Item>,
+            >,
+        ) -> CompoundPredicate<Q::Item>,
+        <Q::Item as HasPrototype>::Prototype<
+            PredicateMarker,
+            BaseProjector<PredicateMarker, Q::Item>,
+        >: Default,
     {
-        use crate::query::predicate::predicate_ast_extensions::AstPredicateExt as _;
+        self.filter(predicate_builder(Default::default()))
+    }
 
-        self.filter(predicate_builder(Default::default()).normalize())
+    /// Return only the fields of the results specified by the given closure.
+    ///
+    /// You can select multiple fields by returning a tuple from the closure.
+    #[must_use]
+    pub fn select_with<B, O>(self, f: B) -> QueryBuilder<'a, E, Q, O::SelectedTuple>
+    where
+        Q::Item: HasPrototype,
+        B: FnOnce(
+            <Q::Item as HasPrototype>::Prototype<
+                SelectorMarker,
+                BaseProjector<SelectorMarker, Q::Item>,
+            >,
+        ) -> O,
+        <Q::Item as HasPrototype>::Prototype<
+            SelectorMarker,
+            BaseProjector<SelectorMarker, Q::Item>,
+        >: Default,
+        O: IntoSelectorTuple<SelectingType = Q::Item>,
+    {
+        let new_selector = f(Default::default()).into_selector_tuple();
+
+        QueryBuilder {
+            query_executor: self.query_executor,
+            query: self.query,
+            filter: self.filter,
+            selector: new_selector,
+            pagination: self.pagination,
+            sorting: self.sorting,
+            fetch_size: self.fetch_size,
+            phantom: PhantomData,
+        }
     }
 
     /// Sort the results according to the specified sorting.
@@ -244,22 +221,20 @@ impl<E, Q, P> QueryBuilder<'_, E, Q, P> {
     }
 }
 
-impl<E, Q, P> QueryBuilder<'_, E, Q, P>
+impl<E, Q, T> QueryBuilder<'_, E, Q, T>
 where
-    E: QueryExecutor,
     Q: Query,
-    Q::Item: HasPredicateBox<PredicateBoxType = P>,
-    QueryBox: From<QueryWithFilterFor<Q>>,
-    Vec<Q::Item>: TryFrom<QueryOutputBatchBox>,
-    <Vec<Q::Item> as TryFrom<QueryOutputBatchBox>>::Error: core::fmt::Debug,
+    E: QueryExecutor,
+    QueryBox: From<QueryWithFilter<Q>>,
+    T: HasTypedBatchIter,
 {
     /// Execute the query, returning an iterator over its results.
     ///
     /// # Errors
     ///
     /// Returns an error if the query execution fails.
-    pub fn execute(self) -> Result<QueryIterator<E, Q::Item>, E::Error> {
-        let with_filter = QueryWithFilter::new(self.query, self.filter);
+    pub fn execute(self) -> Result<QueryIterator<E, T>, E::Error> {
+        let with_filter = QueryWithFilter::new(self.query, self.filter, self.selector);
         let boxed: QueryBox = with_filter.into();
 
         let query = QueryWithParams {
@@ -274,7 +249,7 @@ where
         let (first_batch, remaining_items, continue_cursor) =
             self.query_executor.start_query(query)?;
 
-        let iterator = QueryIterator::<E, Q::Item>::new(first_batch, remaining_items, continue_cursor)
+        let iterator = QueryIterator::<E, T>::new(first_batch, remaining_items, continue_cursor)
             .expect(
                 "INTERNAL BUG: iroha returned unexpected type in iterable query. Is there a schema mismatch?",
             );
@@ -283,65 +258,47 @@ where
     }
 }
 
-impl<E, Q, P> Clone for QueryBuilder<'_, E, Q, P>
-where
-    Q: Clone,
-    P: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            query_executor: self.query_executor,
-            query: self.query.clone(),
-            filter: self.filter.clone(),
-            pagination: self.pagination,
-            sorting: self.sorting.clone(),
-            fetch_size: self.fetch_size,
-        }
-    }
-}
-
 /// An extension trait for query builders that provides convenience methods to execute queries.
-pub trait QueryBuilderExt<E, Q>
+pub trait QueryBuilderExt<E, Q, T>
 where
     E: QueryExecutor,
     Q: Query,
+    T: HasTypedBatchIter,
 {
     /// Execute the query, returning all the results collected into a vector.
     ///
     /// # Errors
     ///
     /// Returns an error if the query execution fails.
-    fn execute_all(self) -> Result<Vec<Q::Item>, E::Error>;
+    fn execute_all(self) -> Result<Vec<T>, E::Error>;
 
     /// Execute the query, constraining the number of results to zero or one.
     ///
     /// # Errors
     ///
     /// Returns an error if the query execution fails or if more than one result is returned.
-    fn execute_single_opt(self) -> Result<Option<Q::Item>, SingleQueryError<E::Error>>;
+    fn execute_single_opt(self) -> Result<Option<T>, SingleQueryError<E::Error>>;
 
     /// Execute the query, constraining the number of results to exactly one.
     ///
     /// # Errors
     ///
     /// Returns an error if the query execution fails or if zero or more than one result is returned.
-    fn execute_single(self) -> Result<Q::Item, SingleQueryError<E::Error>>;
+    fn execute_single(self) -> Result<T, SingleQueryError<E::Error>>;
 }
 
-impl<E, Q, P> QueryBuilderExt<E, Q> for QueryBuilder<'_, E, Q, P>
+impl<E, Q, T> QueryBuilderExt<E, Q, T> for QueryBuilder<'_, E, Q, T>
 where
     E: QueryExecutor,
     Q: Query,
-    Q::Item: HasPredicateBox<PredicateBoxType = P>,
-    QueryBox: From<QueryWithFilterFor<Q>>,
-    Vec<Q::Item>: TryFrom<QueryOutputBatchBox>,
-    <Vec<Q::Item> as TryFrom<QueryOutputBatchBox>>::Error: core::fmt::Debug,
+    QueryBox: From<QueryWithFilter<Q>>,
+    T: HasTypedBatchIter,
 {
-    fn execute_all(self) -> Result<Vec<Q::Item>, E::Error> {
+    fn execute_all(self) -> Result<Vec<T>, E::Error> {
         self.execute()?.collect::<Result<Vec<_>, _>>()
     }
 
-    fn execute_single_opt(self) -> Result<Option<Q::Item>, SingleQueryError<E::Error>> {
+    fn execute_single_opt(self) -> Result<Option<T>, SingleQueryError<E::Error>> {
         let mut iter = self.execute()?;
         let first = iter.next().transpose()?;
         let second = iter.next().transpose()?;
@@ -356,7 +313,7 @@ where
         }
     }
 
-    fn execute_single(self) -> Result<Q::Item, SingleQueryError<E::Error>> {
+    fn execute_single(self) -> Result<T, SingleQueryError<E::Error>> {
         let mut iter = self.execute()?;
         let first = iter.next().transpose()?;
         let second = iter.next().transpose()?;
diff --git a/crates/iroha_data_model/src/query/dsl/compound_predicate.rs b/crates/iroha_data_model/src/query/dsl/compound_predicate.rs
new file mode 100644
index 00000000000..b2535510611
--- /dev/null
+++ b/crates/iroha_data_model/src/query/dsl/compound_predicate.rs
@@ -0,0 +1,135 @@
+#[cfg(not(feature = "std"))]
+use alloc::{boxed::Box, format, string::String, vec, vec::Vec};
+
+use derive_where::derive_where;
+use iroha_macro::serde_where;
+use iroha_schema::IntoSchema;
+use parity_scale_codec::{Decode, Encode};
+use serde::{Deserialize, Serialize};
+
+use crate::query::dsl::{
+    BaseProjector, EvaluatePredicate, HasProjection, HasPrototype, PredicateMarker,
+};
+
+/// A compound predicate that is be used to combine multiple predicates using logical operators.
+#[derive_where(Debug, Eq, PartialEq, Clone; T::Projection)]
+#[serde_where(T::Projection)]
+#[derive(Decode, Encode, Deserialize, Serialize, IntoSchema)]
+pub enum CompoundPredicate<T: HasProjection<PredicateMarker>> {
+    /// A predicate as-is
+    Atom(T::Projection),
+    /// A negation of a compound predicate.
+    Not(Box<CompoundPredicate<T>>),
+    /// A conjunction of multiple predicates.
+    And(Vec<CompoundPredicate<T>>),
+    /// A disjunction of multiple predicates.
+    Or(Vec<CompoundPredicate<T>>),
+}
+
+impl<T: HasProjection<PredicateMarker>> CompoundPredicate<T> {
+    /// A compound predicate that always evaluates to `true`.
+    pub const PASS: Self = Self::And(Vec::new());
+    /// A compound predicate that always evaluates to `false`.
+    pub const FAIL: Self = Self::Or(Vec::new());
+
+    // aliases for logical operations
+    /// Negate the predicate.
+    #[must_use]
+    pub fn not(self) -> Self {
+        !self
+    }
+
+    /// Combine two predicates with an "and" operation.
+    #[must_use]
+    pub fn and(self, other: Self) -> Self {
+        self & other
+    }
+
+    /// Combine two predicates with an "or" operation.
+    #[must_use]
+    pub fn or(self, other: Self) -> Self {
+        self | other
+    }
+}
+
+impl<T> CompoundPredicate<T>
+where
+    T: HasProjection<PredicateMarker>,
+    T::Projection: EvaluatePredicate<T>,
+{
+    /// Evaluate the predicate on the given input.
+    pub fn applies(&self, input: &T) -> bool {
+        match self {
+            CompoundPredicate::Atom(projection) => projection.applies(input),
+            CompoundPredicate::Not(expr) => !expr.applies(input),
+            CompoundPredicate::And(and_list) => and_list.iter().all(|expr| expr.applies(input)),
+            CompoundPredicate::Or(or_list) => or_list.iter().any(|expr| expr.applies(input)),
+        }
+    }
+}
+
+impl<T: HasProjection<PredicateMarker>> core::ops::Not for CompoundPredicate<T> {
+    type Output = CompoundPredicate<T>;
+
+    fn not(self) -> Self::Output {
+        match self {
+            // if the top-level predicate is a negation, we can just remove it
+            CompoundPredicate::Not(expr) => *expr,
+            this => CompoundPredicate::Not(Box::new(this)),
+        }
+    }
+}
+
+impl<T: HasProjection<PredicateMarker>> core::ops::BitAnd for CompoundPredicate<T> {
+    type Output = CompoundPredicate<T>;
+
+    fn bitand(self, other: Self) -> Self::Output {
+        match (self, other) {
+            // if any of the predicates is an and - flatten it
+            (CompoundPredicate::And(mut and_list), other) => {
+                and_list.push(other);
+                CompoundPredicate::And(and_list)
+            }
+            (this, CompoundPredicate::And(mut and_list)) => {
+                // push to front to preserve user-specified order (our predicates are short-circuiting)
+                and_list.insert(0, this);
+                CompoundPredicate::And(and_list)
+            }
+            (this, other) => CompoundPredicate::And(vec![this, other]),
+        }
+    }
+}
+
+impl<T: HasProjection<PredicateMarker>> core::ops::BitOr for CompoundPredicate<T> {
+    type Output = CompoundPredicate<T>;
+
+    fn bitor(self, other: Self) -> Self::Output {
+        match (self, other) {
+            // if any of the predicates is an or - flatten it
+            (CompoundPredicate::Or(mut or_list), other) => {
+                or_list.push(other);
+                CompoundPredicate::Or(or_list)
+            }
+            (this, CompoundPredicate::Or(mut or_list)) => {
+                // push to front to preserve user-specified order (our predicates are short-circuiting)
+                or_list.insert(0, this);
+                CompoundPredicate::Or(or_list)
+            }
+            (this, other) => CompoundPredicate::Or(vec![this, other]),
+        }
+    }
+}
+
+impl<T: HasProjection<PredicateMarker>> CompoundPredicate<T> {
+    /// Build a new compound predicate using the provided closure.
+    pub fn build<F>(f: F) -> Self
+    where
+        T: HasPrototype,
+        F: FnOnce(
+            <T as HasPrototype>::Prototype<PredicateMarker, BaseProjector<PredicateMarker, T>>,
+        ) -> CompoundPredicate<T>,
+        <T as HasPrototype>::Prototype<PredicateMarker, BaseProjector<PredicateMarker, T>>: Default,
+    {
+        f(Default::default())
+    }
+}
diff --git a/crates/iroha_data_model/src/query/dsl/mod.rs b/crates/iroha_data_model/src/query/dsl/mod.rs
new file mode 100644
index 00000000000..153ee2a3da4
--- /dev/null
+++ b/crates/iroha_data_model/src/query/dsl/mod.rs
@@ -0,0 +1,194 @@
+//! This module contains the domain-specific language (DSL) for constructing queries.
+//!
+//! # Prototypes and Projections
+//!
+//! Each data type that can be returned from a query (including nested types) has corresponding prototype and projection types.
+//!
+//! ## Purpose
+//!
+//! Prototypes exist to allow constructing queries with a type-safe API.
+//! They do not get encoded in the query, existing only for the DSL purposes.
+//! They are zero-sized objects that mimic the actual data model types by having the same files as them.
+//! They allow constructing query predicates and selectors with a type-safe API.
+//!
+//! Projections are used as part of the representation of predicates and selectors.
+//! Projections by themselves are used to select a subfield of the data model type (possibly deeply nested).
+//!
+//! ## Usage of prototypes
+//!
+//! The end-user of iroha gets exposed to prototypes when constructing query predicates and selectors.
+//!
+//! For both of these, they have to provide a function that takes a prototype and returns something representing the predicates or selector they want to construct.
+//!
+//! For predicates, they have to return the [`CompoundPredicate`] type, which is by itself a predicate.
+//!
+//! To get this [`CompoundPredicate`] they have to call one of the helper methods on any of the prototypes they've got access to.
+//!
+//! ```rust
+//! # use iroha_data_model::{domain::DomainId, account::AccountId, query::dsl::CompoundPredicate};
+//! let filter_by_domain_name = CompoundPredicate::<AccountId>::build(|account_id| account_id.domain.name.eq("wonderland"));
+//! ```
+//! For selectors, they have to return a type implementing the [`IntoSelectorTuple`] trait.
+//!
+//! It can be either a standalone prototype or a tuple of prototypes.
+//!
+//! ```rust
+//! # use iroha_data_model::{domain::DomainId, account::AccountId, query::dsl::SelectorTuple};
+//! let select_domain_name = SelectorTuple::<AccountId>::build(|account_id| account_id.domain.name);
+//! let select_domain_name_and_signatory =
+//!     SelectorTuple::<AccountId>::build(|account_id| (account_id.domain.name, account_id.signatory));
+//! ```
+//!
+//! ## Implementation details
+//!
+//! Projections types are shared between the filters and selectors by using the [`Projectable`] trait and its marker parameter.
+//! For predicates the marker parameter is [`PredicateMarker`], for selectors it is [`SelectorMarker`].
+//!
+//! All projections have an `Atom` variant, representing the end of field traversal.
+//! They also have variants for each field of the data model type, containing a projection for that field type inside.
+//!
+//! What is stored in the `Atom` variant is decided by the [`Projectable`] trait implementation for the type.
+//!
+//! # Object projectors
+//!
+//! To facilitate conversion of prototypes into actual predicates and selectors, there also exist object projectors implementing the [`ObjectProjector`] trait.
+//!
+//! They get passed as a type parameter to the prototype and describe the path over the type hierarchy that this particular prototype comes from.
+//! An object projector accepts a projection or a selector of a more specific type and returns a projection or a selector of a more general type wrapped in a projection.
+//!
+//! For example, [`type_descriptions::AccountIdDomainProjector`] accepts a predicate or a selector on [`DomainId`](crate::domain::DomainId) and returns a predicate or a selector on [`AccountId`](crate::account::AccountId) by wrapping it with [`type_descriptions::AccountIdProjection`].
+//! Notice the difference between projector and projection: projector is just zero-sized utility type, while projection is actually a predicate or a selector.
+//!
+//! A special kind of projector is a [`BaseProjector`]: it does not change the type of the projection, it just returns it as is.
+//! It used to terminate the recursion in the projector hierarchy.
+//!
+//! # Compound predicates and selectors
+//!
+//! Normally a predicate has just a single condition on a single field.
+//! [`CompoundPredicate`] allows composition of multiple predicates using logical operators.
+//! This is the type that is actually sent when a query is requested.
+//!
+//! A selector also selects just a single field. To allow selecting multiple fields, [`SelectorTuple`] is used in queries.
+
+#[cfg(not(feature = "std"))]
+use alloc::{format, string::String, vec::Vec};
+use core::marker::PhantomData;
+
+mod compound_predicate;
+pub mod predicates;
+mod selector_traits;
+mod selector_tuple;
+pub mod type_descriptions;
+
+use iroha_schema::IntoSchema;
+
+pub use self::{
+    compound_predicate::CompoundPredicate,
+    selector_traits::{IntoSelector, IntoSelectorTuple},
+    selector_tuple::SelectorTuple,
+};
+use crate::query::QueryOutputBatchBox;
+
+/// Trait implemented on all evaluable predicates for type `T`.
+pub trait EvaluatePredicate<T: ?Sized> {
+    /// Evaluate the predicate on the given input.
+    fn applies(&self, input: &T) -> bool;
+}
+
+/// Trait that allows to get the predicate type for a given type.
+pub trait HasPredicateAtom {
+    /// The type of the predicate for this type.
+    type Predicate: EvaluatePredicate<Self>;
+}
+
+/// Trait implemented on all evaluable selectors for type `T`.
+pub trait EvaluateSelector<T: 'static> {
+    /// Select the field from each of the elements in the input and type-erase the result. Cloning version.
+    #[expect(single_use_lifetimes)] // FP, this the suggested change is not allowed on stable
+    fn project_clone<'a>(&self, batch: impl Iterator<Item = &'a T>) -> QueryOutputBatchBox;
+    /// Select the field from each of the elements in the input and type-erase the result.
+    fn project(&self, batch: impl Iterator<Item = T>) -> QueryOutputBatchBox;
+}
+// The IntoSchema derive is only needed for `PredicateMarker` to have `type_name`
+// the actual value of these types is never encoded
+/// A marker type to be used as parameter in the [`Projectable`] trait. This marker is used for predicates.
+#[derive(IntoSchema)]
+#[allow(missing_copy_implementations)]
+pub struct PredicateMarker;
+/// A marker type to be used as parameter in the [`Projectable`] trait. This marker is used for selectors.
+#[derive(IntoSchema)]
+#[allow(missing_copy_implementations)]
+pub struct SelectorMarker;
+
+/// A trait implemented on all types that want to get projection implemented on. It is used by the projection implementation to determine the atom type.
+pub trait Projectable<Marker> {
+    /// The type of the atom for this type. Atom gets stored in the projection when this type ends up being the destination of the type hierarchy traversal.
+    type AtomType;
+}
+
+impl<T: HasPredicateAtom> Projectable<PredicateMarker> for T {
+    // Predicate is the atom for predicates
+    type AtomType = T::Predicate;
+}
+
+impl<T> Projectable<SelectorMarker> for T {
+    // Selectors don't store anything in the atom
+    type AtomType = ();
+}
+
+/// A trait allowing to get the projection for the type.
+pub trait HasProjection<Marker>: Projectable<Marker> {
+    /// The type of the projection for this type.
+    type Projection;
+    /// Construct an atom projection for this type.
+    fn atom(atom: Self::AtomType) -> Self::Projection;
+}
+
+/// A trait allowing to get the prototype for the type.
+pub trait HasPrototype {
+    /// The prototype type for this type.
+    type Prototype<Marker, Projector>: Default + Copy;
+}
+
+/// Describes how to convert a projection on `InputType` to a projection on `OutputType` by wrapping it in a projection.
+pub trait ObjectProjector<Marker> {
+    /// The type of input projection.
+    type InputType: HasProjection<Marker>;
+    /// The type of output projection.
+    type OutputType: HasProjection<Marker>;
+
+    /// Convert the projection on [`Self::InputType`] to a projection on [`Self::OutputType`].
+    fn project(
+        projection: <Self::InputType as HasProjection<Marker>>::Projection,
+    ) -> <Self::OutputType as HasProjection<Marker>>::Projection;
+
+    /// Construct a projection from an atom and convert it to a projection on [`Self::OutputType`].
+    fn wrap_atom(
+        atom: <Self::InputType as Projectable<Marker>>::AtomType,
+    ) -> <Self::OutputType as HasProjection<Marker>>::Projection {
+        let input_projection = <Self::InputType as HasProjection<Marker>>::atom(atom);
+        Self::project(input_projection)
+    }
+}
+
+/// An [`ObjectProjector`] that does not change the type, serving as a base case for the recursion.
+pub struct BaseProjector<Marker, T>(PhantomData<(Marker, T)>);
+
+impl<Marker, T> ObjectProjector<Marker> for BaseProjector<Marker, T>
+where
+    T: HasProjection<Marker>,
+{
+    type InputType = T;
+    type OutputType = T;
+
+    fn project(projection: T::Projection) -> T::Projection {
+        projection
+    }
+}
+
+/// The prelude re-exports most commonly used traits, structs and macros from this crate.
+pub mod prelude {
+    pub use super::{
+        predicates::prelude::*, type_descriptions::prelude::*, CompoundPredicate, SelectorTuple,
+    };
+}
diff --git a/crates/iroha_data_model/src/query/dsl/predicates.rs b/crates/iroha_data_model/src/query/dsl/predicates.rs
new file mode 100644
index 00000000000..3a6d9e23895
--- /dev/null
+++ b/crates/iroha_data_model/src/query/dsl/predicates.rs
@@ -0,0 +1,342 @@
+//! This module contains predicate definitions for all queryable types. See the [module-level documentation](crate::query::dsl) for more information.
+
+#[cfg(not(feature = "std"))]
+use alloc::{format, string::String, vec::Vec};
+
+use iroha_crypto::{HashOf, PublicKey};
+
+use crate::{
+    account::{Account, AccountId},
+    asset::{Asset, AssetDefinition, AssetDefinitionId, AssetId, AssetValue},
+    block::{BlockHeader, SignedBlock},
+    domain::{Domain, DomainId},
+    metadata::Metadata,
+    name::Name,
+    parameter::Parameter,
+    peer::PeerId,
+    permission::Permission,
+    query::{
+        dsl::{
+            type_descriptions::{
+                AccountIdPrototype, AccountPrototype, AssetDefinitionIdPrototype,
+                AssetDefinitionPrototype, AssetIdPrototype, AssetPrototype, AssetValuePrototype,
+                BlockHeaderHashPrototype, BlockHeaderPrototype, CommittedTransactionPrototype,
+                DomainIdPrototype, DomainPrototype, MetadataPrototype, NamePrototype,
+                ParameterPrototype, PeerIdPrototype, PermissionPrototype, PublicKeyPrototype,
+                RoleIdPrototype, RolePrototype, SignedBlockPrototype, SignedTransactionPrototype,
+                StringPrototype, TransactionErrorPrototype, TransactionHashPrototype,
+                TriggerIdPrototype, TriggerPrototype,
+            },
+            CompoundPredicate, ObjectProjector, PredicateMarker,
+        },
+        CommittedTransaction,
+    },
+    role::{Role, RoleId},
+    transaction::{error::TransactionRejectionReason, SignedTransaction},
+    trigger::{Trigger, TriggerId},
+};
+
+macro_rules! impl_predicate_atom {
+    (@impl_evaluate_for_all_types $atom_name:ident $input_name:ident ($($ty_name:ty),*) $body:expr) => {
+        $(
+            impl crate::query::dsl::EvaluatePredicate<$ty_name> for $atom_name {
+                fn applies(&self, $input_name: &$ty_name) -> bool {
+                    ($body)(self)
+                }
+            }
+        )*
+    };
+    (
+        $(
+            $(#[$($atom_attrs:tt)*])*
+            $atom_name:ident($input_name:ident: $ty_name:ty) [$prototype_name:ident] {
+                $(
+                    $(#[$($variant_attrs:tt)*])*
+                    $variant_name:ident$(($variant_pat:ident: $variant_ty:ty))? [$constructor_name:ident] => $variant_expr:expr
+                ),*
+                $(,)?
+            }
+        )*
+    ) => {
+        $(
+            #[doc = concat!("At atomic predicate on [`", stringify!($ty_name), "`]")]
+            #[derive(
+                Debug, Clone, PartialEq, Eq,
+                parity_scale_codec::Decode, parity_scale_codec::Encode, serde::Deserialize, serde::Serialize, iroha_schema::IntoSchema
+            )]
+            // we can't know whether the atom can implement `Copy` or not in this macro
+            // it's also better for future compatibility, since adding branches can make the atom non-`Copy`
+            #[allow(missing_copy_implementations)]
+            $(#[$($atom_attrs)*])*
+            pub enum $atom_name {
+                $(
+                    $(#[$($variant_attrs)*])*
+                    $variant_name$(($variant_ty))?,
+                )*
+            }
+
+
+            impl crate::query::dsl::HasPredicateAtom for $ty_name {
+                type Predicate = $atom_name;
+            }
+
+            // cannot directly put all of the impl blocks here, because rust gets confused with repetitions over $variant_* not being enclosed by repetitions over $ty_name
+            impl_predicate_atom!{ @impl_evaluate_for_all_types $atom_name $input_name ($ty_name)
+                // can't use `self` directly because of the macro hygiene, hence using a closure instead
+                |this: &$atom_name| match *this {
+                    $($atom_name::$variant_name$((ref $variant_pat))? => $variant_expr,)*
+                }
+            }
+
+            // add constructor methods on the prototype
+            impl<Projector> $prototype_name<PredicateMarker, Projector>
+            where
+                Projector: ObjectProjector<PredicateMarker, InputType = $ty_name>,
+            {
+                $(
+                    $(#[$($variant_attrs)*])*
+                    pub fn $constructor_name(self $(, $variant_pat: $variant_ty)?) -> CompoundPredicate<Projector::OutputType> {
+                        CompoundPredicate::Atom(Projector::wrap_atom(
+                            $atom_name::$variant_name$(($variant_pat))?
+                        ))
+                    }
+                )*
+            }
+        )*
+    };
+}
+
+/// An atomic predicate on [`String`] or [`Name`]
+// Defined separately because it is shared between [String] and [Name]
+#[derive(
+    Debug,
+    Clone,
+    PartialEq,
+    Eq,
+    parity_scale_codec::Decode,
+    parity_scale_codec::Encode,
+    serde::Deserialize,
+    serde::Serialize,
+    iroha_schema::IntoSchema,
+)]
+pub enum StringPredicateAtom {
+    /// Checks if the input is equal to the expected value.
+    Equals(String),
+    /// Checks if the input contains an expected substring, like [`str::contains()`].
+    Contains(String),
+    /// Checks if the input starts with an expected substring, like [`str::starts_with()`].
+    StartsWith(String),
+    /// Checks if the input ends with an expected substring, like [`str::ends_with()`].
+    EndsWith(String),
+}
+
+impl super::HasPredicateAtom for String {
+    type Predicate = StringPredicateAtom;
+}
+
+impl super::HasPredicateAtom for Name {
+    type Predicate = StringPredicateAtom;
+}
+
+impl StringPredicateAtom {
+    fn applies_to_str(&self, input: &str) -> bool {
+        match self {
+            StringPredicateAtom::Equals(content) => input == content,
+            StringPredicateAtom::Contains(content) => input.contains(content),
+            StringPredicateAtom::StartsWith(content) => input.starts_with(content),
+            StringPredicateAtom::EndsWith(content) => input.ends_with(content),
+        }
+    }
+}
+
+impl super::EvaluatePredicate<String> for StringPredicateAtom {
+    fn applies(&self, input: &String) -> bool {
+        self.applies_to_str(input.as_str())
+    }
+}
+
+impl super::EvaluatePredicate<Name> for StringPredicateAtom {
+    fn applies(&self, input: &Name) -> bool {
+        self.applies_to_str(input.as_ref())
+    }
+}
+
+// It is unfortunate that we have to repeat the prototype methods on String and Name, but I don't think it's possible to remove this duplication
+impl<Projection> StringPrototype<PredicateMarker, Projection>
+where
+    Projection: ObjectProjector<PredicateMarker, InputType = String>,
+{
+    /// Checks if the input is equal to the expected value.
+    pub fn eq(self, expected: impl Into<String>) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::Equals(
+            expected.into(),
+        )))
+    }
+
+    /// Checks if the input contains an expected substring, like [`str::contains()`].
+    pub fn contains(
+        self,
+        expected: impl Into<String>,
+    ) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::Contains(
+            expected.into(),
+        )))
+    }
+
+    /// Checks if the input starts with an expected substring, like [`str::starts_with()`].
+    pub fn starts_with(
+        self,
+        expected: impl Into<String>,
+    ) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::StartsWith(
+            expected.into(),
+        )))
+    }
+
+    /// Checks if the input ends with an expected substring, like [`str::ends_with()`].
+    pub fn ends_with(
+        self,
+        expected: impl Into<String>,
+    ) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::EndsWith(
+            expected.into(),
+        )))
+    }
+}
+
+impl<Projection> NamePrototype<PredicateMarker, Projection>
+where
+    Projection: ObjectProjector<PredicateMarker, InputType = Name>,
+{
+    /// Checks if the input is equal to the expected value.
+    pub fn eq(self, expected: impl Into<String>) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::Equals(
+            expected.into(),
+        )))
+    }
+
+    /// Checks if the input contains an expected substring, like [`str::contains()`].
+    pub fn contains(
+        self,
+        expected: impl Into<String>,
+    ) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::Contains(
+            expected.into(),
+        )))
+    }
+
+    /// Checks if the input starts with an expected substring, like [`str::starts_with()`].
+    pub fn starts_with(
+        self,
+        expected: impl Into<String>,
+    ) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::StartsWith(
+            expected.into(),
+        )))
+    }
+
+    /// Checks if the input ends with an expected substring, like [`str::ends_with()`].
+    pub fn ends_with(
+        self,
+        expected: impl Into<String>,
+    ) -> CompoundPredicate<Projection::OutputType> {
+        CompoundPredicate::Atom(Projection::wrap_atom(StringPredicateAtom::EndsWith(
+            expected.into(),
+        )))
+    }
+}
+
+impl_predicate_atom! {
+    MetadataPredicateAtom(_input: Metadata) [MetadataPrototype] {
+        // TODO: populate
+    }
+    PublicKeyPredicateAtom(input: PublicKey) [PublicKeyPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: PublicKey) [eq] => input == expected,
+    }
+
+    // account
+    AccountIdPredicateAtom(input: AccountId) [AccountIdPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: AccountId) [eq] => input == expected,
+    }
+    AccountPredicateAtom(_input: Account) [AccountPrototype] {}
+
+    // asset
+    AssetDefinitionPredicateAtom(_input: AssetDefinition) [AssetDefinitionPrototype] {}
+    AssetPredicateAtom(_input: Asset) [AssetPrototype] {}
+    AssetValuePredicateAtom(_input: AssetValue) [AssetValuePrototype] {
+        // TODO: populate
+    }
+    AssetIdPredicateAtom(input: AssetId) [AssetIdPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: AssetId) [eq] => input == expected,
+    }
+    AssetDefinitionIdPredicateAtom(input: AssetDefinitionId) [AssetDefinitionIdPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: AssetDefinitionId) [eq] => input == expected,
+    }
+
+    // block
+    BlockHeaderHashPredicateAtom(input: HashOf<BlockHeader>) [BlockHeaderHashPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: HashOf<BlockHeader>) [eq] => input == expected,
+    }
+    BlockHeaderPredicateAtom(_input: BlockHeader) [BlockHeaderPrototype] {}
+    SignedBlockPredicateAtom(_input: SignedBlock) [SignedBlockPrototype] {}
+    TransactionHashPredicateAtom(input: HashOf<SignedTransaction>) [TransactionHashPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: HashOf<SignedTransaction>) [eq] => input == expected,
+    }
+    SignedTransactionPredicateAtom(_input: SignedTransaction) [SignedTransactionPrototype] {}
+    TransactionErrorPredicateAtom(input: Option<TransactionRejectionReason>) [TransactionErrorPrototype] {
+        /// Checks if there was an error while applying the transaction.
+        IsSome [is_some] => input.is_some(),
+    }
+    CommittedTransactionPredicateAtom(_input: CommittedTransaction) [CommittedTransactionPrototype] {}
+
+    // domain
+    DomainPredicateAtom(_input: Domain) [DomainPrototype] {}
+    DomainIdPredicateAtom(input: DomainId) [DomainIdPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: DomainId) [eq] => input == expected,
+    }
+
+    // peer
+    PeerIdPredicateAtom(_input: PeerId) [PeerIdPrototype] {}
+
+    // permission
+    PermissionPredicateAtom(_input: Permission) [PermissionPrototype] {}
+
+    // parameter
+    ParameterPredicateAtom(_input: Parameter) [ParameterPrototype] {}
+
+    // role
+    RoleIdPredicateAtom(input: RoleId) [RoleIdPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: RoleId) [eq] => input == expected,
+    }
+    RolePredicateAtom(_input: Role) [RolePrototype] {}
+
+    // trigger
+    TriggerIdPredicateAtom(input: TriggerId) [TriggerIdPrototype] {
+        /// Checks if the input is equal to the expected value.
+        Equals(expected: TriggerId) [eq] => input == expected,
+    }
+    TriggerPredicateAtom(_input: Trigger) [TriggerPrototype] {}
+}
+
+pub mod prelude {
+    //! Re-export all predicate boxes for a glob import `(::*)`
+    pub use super::{
+        AccountIdPredicateAtom, AccountPredicateAtom, AssetDefinitionIdPredicateAtom,
+        AssetDefinitionPredicateAtom, AssetIdPredicateAtom, AssetPredicateAtom,
+        AssetValuePredicateAtom, BlockHeaderHashPredicateAtom, BlockHeaderPredicateAtom,
+        CommittedTransactionPredicateAtom, DomainIdPredicateAtom, DomainPredicateAtom,
+        MetadataPredicateAtom, ParameterPredicateAtom, PeerIdPredicateAtom,
+        PermissionPredicateAtom, PublicKeyPredicateAtom, RoleIdPredicateAtom, RolePredicateAtom,
+        SignedBlockPredicateAtom, SignedTransactionPredicateAtom, StringPredicateAtom,
+        TransactionErrorPredicateAtom, TransactionHashPredicateAtom, TriggerIdPredicateAtom,
+        TriggerPredicateAtom,
+    };
+}
diff --git a/crates/iroha_data_model/src/query/dsl/selector_traits.rs b/crates/iroha_data_model/src/query/dsl/selector_traits.rs
new file mode 100644
index 00000000000..7e9e28f9473
--- /dev/null
+++ b/crates/iroha_data_model/src/query/dsl/selector_traits.rs
@@ -0,0 +1,73 @@
+#[cfg(not(feature = "std"))]
+use alloc::vec;
+
+use crate::{
+    prelude::SelectorTuple,
+    query::dsl::{HasProjection, SelectorMarker},
+};
+
+/// A trait implemented on all types that can be converted into a selector (usually prototypes).
+pub trait IntoSelector {
+    /// A type that the selector is selecting from
+    type SelectingType: HasProjection<SelectorMarker, AtomType = ()>;
+    /// A type that the selector ends up selecting
+    // Note that this type is not exposed by the converted selector
+    // As such, it is not possible to do type-safe queries just by looking at the selector, a type implementing this trait must be used
+    type SelectedType;
+    /// Convert the type into a selector
+    fn into_selector(self) -> <Self::SelectingType as HasProjection<SelectorMarker>>::Projection;
+}
+
+/// A trait implemented on all types that can be converted into a selector tuple (usually prototypes).
+pub trait IntoSelectorTuple {
+    /// A type that the selector is selecting from
+    type SelectingType: HasProjection<SelectorMarker, AtomType = ()>;
+    /// A tuple of types that the selector ends up selecting
+    type SelectedTuple;
+    /// Convert the type into a selector tuple
+    fn into_selector_tuple(self) -> SelectorTuple<Self::SelectingType>;
+}
+
+impl<T: IntoSelector> IntoSelectorTuple for T {
+    type SelectingType = T::SelectingType;
+    type SelectedTuple = T::SelectedType;
+
+    fn into_selector_tuple(self) -> SelectorTuple<Self::SelectingType> {
+        SelectorTuple::new(vec![self.into_selector()])
+    }
+}
+
+impl<T1: IntoSelector> IntoSelectorTuple for (T1,) {
+    type SelectingType = T1::SelectingType;
+    type SelectedTuple = (T1::SelectedType,);
+
+    fn into_selector_tuple(self) -> SelectorTuple<Self::SelectingType> {
+        SelectorTuple::new(vec![self.0.into_selector()])
+    }
+}
+
+macro_rules! impl_into_selector_tuple {
+    ($t1_name:ident, $($t_name:ident),*) => {
+        impl<$t1_name: IntoSelector, $($t_name: IntoSelector<SelectingType = T1::SelectingType>),*> IntoSelectorTuple for ($t1_name, $($t_name),*)
+        {
+            type SelectingType = $t1_name::SelectingType;
+            type SelectedTuple = ($t1_name::SelectedType, $($t_name::SelectedType),*);
+
+            #[allow(non_snake_case)] // we re-use the type names as variable names to not require the user to come up with new ones in the macro invocation
+            fn into_selector_tuple(self) -> SelectorTuple<Self::SelectingType> {
+                let ($t1_name, $($t_name),*) = self;
+                SelectorTuple::new(vec![
+                    $t1_name.into_selector(),
+                    $($t_name.into_selector(),)*
+                ])
+            }
+        }
+    };
+}
+impl_into_selector_tuple!(T1, T2);
+impl_into_selector_tuple!(T1, T2, T3);
+impl_into_selector_tuple!(T1, T2, T3, T4);
+impl_into_selector_tuple!(T1, T2, T3, T4, T5);
+impl_into_selector_tuple!(T1, T2, T3, T4, T5, T6);
+impl_into_selector_tuple!(T1, T2, T3, T4, T5, T6, T7);
+impl_into_selector_tuple!(T1, T2, T3, T4, T5, T6, T7, T8);
diff --git a/crates/iroha_data_model/src/query/dsl/selector_tuple.rs b/crates/iroha_data_model/src/query/dsl/selector_tuple.rs
new file mode 100644
index 00000000000..e6797dbf34e
--- /dev/null
+++ b/crates/iroha_data_model/src/query/dsl/selector_tuple.rs
@@ -0,0 +1,51 @@
+#[cfg(not(feature = "std"))]
+use alloc::{format, string::String, vec, vec::Vec};
+
+use derive_where::derive_where;
+use iroha_macro::serde_where;
+use iroha_schema::IntoSchema;
+use parity_scale_codec::{Decode, Encode};
+use serde::{Deserialize, Serialize};
+
+use crate::query::dsl::{
+    BaseProjector, HasProjection, HasPrototype, IntoSelectorTuple, SelectorMarker,
+};
+
+/// A tuple of selectors selecting some subfields from `T`.
+#[derive_where(Debug, Eq, PartialEq, Clone; T::Projection)]
+#[serde_where(T::Projection)]
+#[derive(Decode, Encode, Deserialize, Serialize, IntoSchema)]
+pub struct SelectorTuple<T: HasProjection<SelectorMarker, AtomType = ()>>(Vec<T::Projection>);
+
+impl<T: HasProjection<SelectorMarker, AtomType = ()>> SelectorTuple<T> {
+    /// Create a new selector tuple from a list of selectors.
+    pub fn new(selectors: Vec<T::Projection>) -> Self {
+        Self(selectors)
+    }
+
+    /// Build a selector tuple using a prototype.
+    ///
+    /// Note that unlike predicates, the result of this function cannot be fed into the query builder.
+    pub fn build<F, O>(f: F) -> Self
+    where
+        T: HasPrototype,
+        F: FnOnce(
+            <T as HasPrototype>::Prototype<SelectorMarker, BaseProjector<SelectorMarker, T>>,
+        ) -> O,
+        <T as HasPrototype>::Prototype<SelectorMarker, BaseProjector<SelectorMarker, T>>: Default,
+        O: IntoSelectorTuple<SelectingType = T>,
+    {
+        f(Default::default()).into_selector_tuple()
+    }
+
+    /// Iterate over the selectors in the tuple.
+    pub fn iter(&self) -> impl Iterator<Item = &T::Projection> {
+        self.0.iter()
+    }
+}
+
+impl<T: HasProjection<SelectorMarker, AtomType = ()>> Default for SelectorTuple<T> {
+    fn default() -> Self {
+        Self(vec![T::atom(())])
+    }
+}
diff --git a/crates/iroha_data_model/src/query/dsl/type_descriptions.rs b/crates/iroha_data_model/src/query/dsl/type_descriptions.rs
new file mode 100644
index 00000000000..31d0512eb3d
--- /dev/null
+++ b/crates/iroha_data_model/src/query/dsl/type_descriptions.rs
@@ -0,0 +1,440 @@
+//! This module contains definitions of prototypes and projections for the data model types. See the [module-level documentation](crate::query::dsl) for more information.
+
+#[cfg(not(feature = "std"))]
+use alloc::{format, string::String, vec::Vec};
+
+use derive_where::derive_where;
+use iroha_crypto::{HashOf, PublicKey};
+
+// used in the macro
+use crate::query::dsl::{
+    EvaluatePredicate, EvaluateSelector, HasProjection, HasPrototype, IntoSelector,
+    ObjectProjector, PredicateMarker, Projectable, SelectorMarker,
+};
+use crate::{
+    account::{Account, AccountId},
+    asset::{Asset, AssetDefinition, AssetDefinitionId, AssetId, AssetValue},
+    block::{BlockHeader, SignedBlock},
+    domain::{Domain, DomainId},
+    metadata::Metadata,
+    name::Name,
+    parameter::Parameter,
+    peer::PeerId,
+    permission::Permission,
+    query::{CommittedTransaction, QueryOutputBatchBox},
+    role::{Role, RoleId},
+    transaction::{error::TransactionRejectionReason, SignedTransaction},
+    trigger::{Trigger, TriggerId},
+};
+
+macro_rules! type_descriptions {
+    (@check_attrs) => {};
+    (@check_attrs #[custom_evaluate] $($rest:tt)*) => {
+        type_descriptions!(@check_attrs $($rest)*);
+    };
+
+    (@evaluate
+        (#[custom_evaluate] $($rest:tt)*)
+        ($ty:ty) $projection_name:ident
+        ($($field_name:ident($proj_variant:ident))*)
+    ) => {
+        // the user has requested a custom evaluation impl, so do not derive it
+    };
+    (@evaluate
+        ()
+        ($ty:ty) $projection_name:ident
+        ($($field_name:ident($proj_variant:ident))*)
+    ) => {
+        impl EvaluatePredicate<$ty> for $projection_name<PredicateMarker> {
+            fn applies(&self, input: &$ty) -> bool {
+                match self {
+                    $projection_name::Atom(atom) => atom.applies(input),
+                    $(
+                        $projection_name::$proj_variant(field) => EvaluatePredicate::applies(field, &input.$field_name),
+                    )*
+                }
+            }
+        }
+
+        impl EvaluateSelector<$ty> for $projection_name<SelectorMarker> {
+                #[expect(single_use_lifetimes)] // FP, this the suggested change is not allowed on stable
+                fn project_clone<'a>(&self, batch: impl Iterator<Item = &'a $ty>) -> QueryOutputBatchBox {
+                    match self {
+                        $projection_name::Atom(_) => batch.cloned().collect::<Vec<_>>().into(),
+                        $(
+                            $projection_name::$proj_variant(field) => field.project_clone(batch.map(|item| &item.$field_name)),
+                        )*
+                    }
+                }
+
+                fn project(&self, batch: impl Iterator<Item = $ty>) -> QueryOutputBatchBox {
+                    match self {
+                        $projection_name::Atom(_) => batch.collect::<Vec<_>>().into(),
+                        $(
+                            $projection_name::$proj_variant(field) => field.project(batch.map(|item| item.$field_name)),
+                        )*
+                    }
+                }
+        }
+    };
+    (@object_projector
+        ($ty:ty) $projection_name:ident
+        ($field_name:ident($proj_variant:ident, $projector_name:ident): $field_ty:ty)
+        // unpack tt sequence back
+        ($($dep_ty_bounds:tt)*)
+    ) => {
+        #[doc = concat!("A projector on [`", stringify!($ty), "`] for its `", stringify!($field_name), "` field.")]
+        pub struct $projector_name<Marker, Base>(core::marker::PhantomData<(Marker, Base)>);
+
+        impl<Marker, Base> ObjectProjector<Marker> for $projector_name<Marker, Base>
+        where
+            Base: ObjectProjector<Marker, InputType = $ty>,
+            $ty: Projectable<Marker>
+            $($dep_ty_bounds)*
+        {
+            type InputType = $field_ty;
+            type OutputType = Base::OutputType;
+
+            fn project(
+                projection: <$field_ty as HasProjection<Marker>>::Projection
+            ) -> <Self::OutputType as HasProjection<Marker>>::Projection {
+                Base::project($projection_name::$proj_variant(projection))
+            }
+        }
+    };
+    (@object_projector_repeated
+        ($ty:ty) $projection_name:ident
+        ($(
+            $field_name:ident($proj_variant:ident, $projector_name:ident): $field_ty:ty,
+        )*)
+        // smuggle a tt sequence as a single tt
+        $dep_ty_bounds:tt
+    ) => {
+        $(
+            type_descriptions!{ @object_projector ($ty) $projection_name
+                ($field_name($proj_variant, $projector_name): $field_ty)
+                $dep_ty_bounds
+            }
+        )*
+    };
+
+    ($(
+        $(#[$($attrs:tt)*])*
+        $ty:ty[$projection_name:ident, $prototype_name:ident] $(: $($dep_ty:ty),+)? {
+        $(
+            $field_name:ident($proj_variant:ident, $projector_name:ident): $field_ty:ty,
+        )*
+        }
+    )*) => {
+        $(
+            type_descriptions!(@check_attrs $(#[$($attrs)*])*);
+
+            // hints to the IDE that these are types
+            #[allow(unused_variables)]
+            const _:() = {
+                let t: $ty;
+                $($(let t: $dep_ty;)+)?
+                $(let t: $field_ty;)*
+            };
+
+            // projection enum
+            #[doc = concat!("A projection for the [`", stringify!($ty), "`] type.")]
+            // use derive_where to generate trait bounds
+            #[derive_where::derive_where(Debug, Eq, PartialEq, Copy, Clone;
+                <$ty as Projectable<Marker>>::AtomType
+                $(, <$field_ty as HasProjection<Marker>>::Projection)*
+            )]
+            // parity-scale-codec and iroha_schema generates correct bounds by themselves
+            #[derive(parity_scale_codec::Decode, parity_scale_codec::Encode, iroha_schema::IntoSchema)]
+            // use serde_where macro to generate the correct #[serde(bounds(...))] attribute
+            #[iroha_macro::serde_where(
+                <$ty as Projectable<Marker>>::AtomType
+                $(, <$field_ty as HasProjection<Marker>>::Projection)*
+            )]
+            #[derive(serde::Deserialize, serde::Serialize)]
+            pub enum $projection_name<Marker>
+            where
+                $ty: Projectable<Marker>
+                $($(, $dep_ty: HasProjection<Marker>)*)?
+            {
+                #[doc = "Finish the projection with an atom."]
+                Atom(<$ty as Projectable<Marker>>::AtomType),
+                $(
+                    #[doc = concat!("Projection for the `", stringify!($field_name), "` field.")]
+                    $proj_variant(
+                        <$field_ty as HasProjection<Marker>>::Projection
+                    ),
+                )*
+            }
+
+            impl<Marker> HasProjection<Marker> for $ty
+            where
+                $ty: Projectable<Marker>
+                $($(, $dep_ty: HasProjection<Marker>)*)?
+            {
+                type Projection = $projection_name<Marker>;
+
+                fn atom(atom: Self::AtomType) -> Self::Projection {
+                    $projection_name::Atom(atom)
+                }
+            }
+
+            type_descriptions!(@evaluate
+                ($(#[$($attrs)*])*)
+                ($ty) $projection_name
+                ($($field_name($proj_variant))*)
+            );
+
+            // projector structs
+            // because we need to repeat $dep_ty inside a disjoint repetition, use another macro
+            type_descriptions!(@object_projector_repeated ($ty) $projection_name ($(
+                $field_name($proj_variant, $projector_name): $field_ty,
+            )*) ($(, $($dep_ty: Projectable<Marker>),*)?));
+
+            // prototype struct
+            #[doc = concat!("A prototype for the [`", stringify!($ty), "`] type.")]
+            #[derive_where::derive_where(Default, Copy, Clone)]
+            pub struct $prototype_name<Marker, Projector> {
+                $(
+                    // TODO: I think it might make sense to provide field documentation here. How would we do that without copying the docs to the type description macro though?
+                    #[doc = concat!("Accessor for the `", stringify!($field_name), "` field.")]
+                    pub $field_name: <$field_ty as HasPrototype>::Prototype<Marker, $projector_name<Marker, Projector>>,
+                )*
+                phantom: core::marker::PhantomData<(Marker, Projector)>,
+            }
+
+            impl HasPrototype for $ty
+            {
+                type Prototype<Marker, Projector> = $prototype_name<Marker, Projector>;
+            }
+
+            impl<Projector> IntoSelector for $prototype_name<SelectorMarker, Projector>
+            where
+                Projector: ObjectProjector<SelectorMarker, InputType = $ty>,
+                Projector::OutputType: HasProjection<SelectorMarker, AtomType = ()>,
+            {
+                type SelectingType = Projector::OutputType;
+                type SelectedType = Projector::InputType;
+
+                fn into_selector(self) -> <Projector::OutputType as HasProjection<SelectorMarker>>::Projection {
+                    Projector::wrap_atom(())
+                }
+            }
+        )*
+
+        mod projections {
+            $(
+                pub use super::$projection_name;
+            )*
+        }
+    };
+}
+
+type_descriptions! {
+    // Type[ProjectionName, PrototypeName]: Dependency1, Dependency2, ...
+    Account[AccountProjection, AccountPrototype]: AccountId, DomainId, Name, PublicKey, Metadata {
+        // field_name(ProjectionVariant, ProjectorName): FieldType
+        id(Id, AccountIdProjector): AccountId,
+        metadata(Metadata, AccountMetadataProjector): Metadata,
+    }
+    AccountId[AccountIdProjection, AccountIdPrototype]: DomainId, Name, PublicKey {
+        domain(Domain, AccountIdDomainProjector): DomainId,
+        signatory(Signatory, AccountIdSignatoryProjector): PublicKey,
+    }
+
+    // asset
+    AssetDefinition[AssetDefinitionProjection, AssetDefinitionPrototype]: AssetDefinitionId, DomainId, Name, Metadata {
+        id(Id, AssetDefinitionIdProjector): AssetDefinitionId,
+        metadata(Metadata, AssetDefinitionMetadataProjector): Metadata,
+    }
+    AssetDefinitionId[AssetDefinitionIdProjection, AssetDefinitionIdPrototype]: DomainId, Name {
+        domain(Domain, AssetDefinitionIdDomainProjector): DomainId,
+        name(Name, AssetDefinitionIdNameProjector): Name,
+    }
+    Asset[AssetProjection, AssetPrototype]: AssetId, AccountId, DomainId, Name, PublicKey, AssetDefinitionId, AssetValue {
+        id(Id, AssetIdProjector): AssetId,
+        value(Value, AssetValueProjector): AssetValue,
+    }
+    AssetId[AssetIdProjection, AssetIdPrototype]: AccountId, DomainId, Name, PublicKey, AssetDefinitionId {
+        account(Account, AssetIdAccountProjector): AccountId,
+        definition(Definition, AssetIdDefinitionProjector): AssetDefinitionId,
+    }
+    AssetValue[AssetValueProjection, AssetValuePrototype] {}
+
+    // block
+    HashOf<BlockHeader>[BlockHeaderHashProjection, BlockHeaderHashPrototype] {}
+    #[custom_evaluate] // hash needs to be computed on-the-fly
+    BlockHeader[BlockHeaderProjection, BlockHeaderPrototype]: HashOf<BlockHeader> {
+        hash(Hash, BlockHeaderHashProjector): HashOf<BlockHeader>,
+    }
+    #[custom_evaluate] // SignedBlock is opaque, so `header` is a method
+    SignedBlock[SignedBlockProjection, SignedBlockPrototype]: BlockHeader, HashOf<BlockHeader> {
+        header(Header, SignedBlockHeaderProjector): BlockHeader,
+    }
+    HashOf<SignedTransaction>[TransactionHashProjection, TransactionHashPrototype] {}
+    #[custom_evaluate] // hash needs to be computed on-the-fly
+    SignedTransaction[SignedTransactionProjection, SignedTransactionPrototype]: HashOf<SignedTransaction>, AccountId, DomainId, Name, PublicKey {
+        hash(Hash, SignedTransactionHashProjector): HashOf<SignedTransaction>,
+        authority(Authority, SignedTransactionAuthorityProjector): AccountId,
+    }
+    Option<TransactionRejectionReason>[TransactionErrorProjection, TransactionErrorPrototype] {}
+    CommittedTransaction[CommittedTransactionProjection, CommittedTransactionPrototype]: HashOf<BlockHeader>, SignedTransaction, HashOf<SignedTransaction>, AccountId, DomainId, Name, PublicKey, Option<TransactionRejectionReason> {
+        block_hash(BlockHash, CommittedTransactionBlockHashProjector): HashOf<BlockHeader>,
+        value(Value, CommittedTransactionValueProjector): SignedTransaction,
+        error(Error, CommittedTransactionErrorProjector): Option<TransactionRejectionReason>,
+    }
+
+    // domain
+    Domain[DomainProjection, DomainPrototype]: DomainId, Name, Metadata {
+        id(Id, DomainIdProjector): DomainId,
+        metadata(Metadata, DomainMetadataProjector): Metadata,
+    }
+    DomainId[DomainIdProjection, DomainIdPrototype]: Name {
+        name(Name, DomainIdNameProjector): Name,
+    }
+
+    // peer
+    PeerId[PeerIdProjection, PeerIdPrototype]: PublicKey {
+        public_key(PublicKey, PeerIdPublicKeyProjector): PublicKey,
+    }
+
+    // permission
+    Permission[PermissionProjection, PermissionPrototype] {}
+
+    // parameter
+    Parameter[ParameterProjection, ParameterPrototype] {}
+
+    // role
+    RoleId[RoleIdProjection, RoleIdPrototype]: Name {
+        name(Name, RoleIdNameProjector): Name,
+    }
+    Role[RoleProjection, RolePrototype]: RoleId, Name {
+        id(Id, RoleIdProjector): RoleId,
+        // TODO: it would be nice to have predicate on permissions, but we do not support  predicates on collections yet
+        // permissions(Permissions, RolePermissionsProjector): Permissions,
+    }
+
+    // trigger
+    TriggerId[TriggerIdProjection, TriggerIdPrototype]: Name {
+        name(Name, TriggerIdNameProjector): Name,
+    }
+    Trigger[TriggerProjection, TriggerPrototype]: TriggerId, Name {
+        id(Id, TriggerIdProjector): TriggerId,
+    }
+
+    // note: even though `NameProjection` and `StringProjection` are distinct types,
+    // their predicates types are the same
+    Name[NameProjection, NamePrototype] {}
+    String[StringProjection, StringPrototype] {}
+
+    PublicKey[PublicKeyProjection, PublicKeyPrototype] {}
+    Metadata[MetadataProjection, MetadataPrototype] {
+        // TODO: we will probably want to have a special-cased metadata projection that allows accessing fields by string keys (because metadata is not statically typed)
+    }
+}
+
+// evaluate implementations that could not be implemented in a macro
+impl EvaluatePredicate<BlockHeader> for BlockHeaderProjection<PredicateMarker> {
+    fn applies(&self, input: &BlockHeader) -> bool {
+        match self {
+            BlockHeaderProjection::Atom(atom) => atom.applies(input),
+            BlockHeaderProjection::Hash(hash) => hash.applies(&input.hash()),
+        }
+    }
+}
+
+impl EvaluateSelector<BlockHeader> for BlockHeaderProjection<SelectorMarker> {
+    #[expect(single_use_lifetimes)] // FP, this the suggested change is not allowed on stable
+    fn project_clone<'a>(
+        &self,
+        batch: impl Iterator<Item = &'a BlockHeader>,
+    ) -> QueryOutputBatchBox {
+        match self {
+            BlockHeaderProjection::Atom(_) => batch.cloned().collect::<Vec<_>>().into(),
+            BlockHeaderProjection::Hash(hash) => hash.project(batch.map(|item| item.hash())),
+        }
+    }
+
+    fn project(&self, batch: impl Iterator<Item = BlockHeader>) -> QueryOutputBatchBox {
+        match self {
+            BlockHeaderProjection::Atom(_) => batch.collect::<Vec<_>>().into(),
+            BlockHeaderProjection::Hash(hash) => hash.project(batch.map(|item| item.hash())),
+        }
+    }
+}
+
+impl EvaluatePredicate<SignedBlock> for SignedBlockProjection<PredicateMarker> {
+    fn applies(&self, input: &SignedBlock) -> bool {
+        match self {
+            SignedBlockProjection::Atom(atom) => atom.applies(input),
+            SignedBlockProjection::Header(header) => header.applies(&input.header()),
+        }
+    }
+}
+
+impl EvaluateSelector<SignedBlock> for SignedBlockProjection<SelectorMarker> {
+    #[expect(single_use_lifetimes)] // FP, this the suggested change is not allowed on stable
+    fn project_clone<'a>(
+        &self,
+        batch: impl Iterator<Item = &'a SignedBlock>,
+    ) -> QueryOutputBatchBox {
+        match self {
+            SignedBlockProjection::Atom(_) => batch.cloned().collect::<Vec<_>>().into(),
+            SignedBlockProjection::Header(header) => {
+                header.project(batch.map(|item| item.header()))
+            }
+        }
+    }
+
+    fn project(&self, batch: impl Iterator<Item = SignedBlock>) -> QueryOutputBatchBox {
+        match self {
+            SignedBlockProjection::Atom(_) => batch.collect::<Vec<_>>().into(),
+            SignedBlockProjection::Header(header) => {
+                header.project(batch.map(|item| item.header()))
+            }
+        }
+    }
+}
+
+impl EvaluatePredicate<SignedTransaction> for SignedTransactionProjection<PredicateMarker> {
+    fn applies(&self, input: &SignedTransaction) -> bool {
+        match self {
+            SignedTransactionProjection::Atom(atom) => atom.applies(input),
+            SignedTransactionProjection::Hash(hash) => hash.applies(&input.hash()),
+            SignedTransactionProjection::Authority(authority) => {
+                authority.applies(&input.authority())
+            }
+        }
+    }
+}
+
+impl EvaluateSelector<SignedTransaction> for SignedTransactionProjection<SelectorMarker> {
+    #[expect(single_use_lifetimes)] // FP, this the suggested change is not allowed on stable
+    fn project_clone<'a>(
+        &self,
+        batch: impl Iterator<Item = &'a SignedTransaction>,
+    ) -> QueryOutputBatchBox {
+        match self {
+            SignedTransactionProjection::Atom(_) => batch.cloned().collect::<Vec<_>>().into(),
+            SignedTransactionProjection::Hash(hash) => hash.project(batch.map(|item| item.hash())),
+            SignedTransactionProjection::Authority(authority) => {
+                authority.project_clone(batch.map(|item| item.authority()))
+            }
+        }
+    }
+
+    fn project(&self, batch: impl Iterator<Item = SignedTransaction>) -> QueryOutputBatchBox {
+        match self {
+            SignedTransactionProjection::Atom(_) => batch.collect::<Vec<_>>().into(),
+            SignedTransactionProjection::Hash(hash) => hash.project(batch.map(|item| item.hash())),
+            SignedTransactionProjection::Authority(authority) => {
+                authority.project(batch.map(|item| item.authority().clone()))
+            }
+        }
+    }
+}
+
+pub mod prelude {
+    //! Re-export all projections for a glob import `(::*)`
+    pub use super::projections::*;
+}
diff --git a/crates/iroha_data_model/src/query/mod.rs b/crates/iroha_data_model/src/query/mod.rs
index 39038062783..4a488943a27 100644
--- a/crates/iroha_data_model/src/query/mod.rs
+++ b/crates/iroha_data_model/src/query/mod.rs
@@ -18,14 +18,16 @@ use serde::{Deserialize, Serialize};
 
 pub use self::model::*;
 use self::{
-    account::*, asset::*, block::*, domain::*, executor::*, peer::*, permission::*, predicate::*,
+    account::*, asset::*, block::*, domain::*, dsl::*, executor::*, peer::*, permission::*,
     role::*, transaction::*, trigger::*,
 };
 use crate::{
     account::{Account, AccountId},
-    asset::{Asset, AssetDefinition},
+    asset::{Asset, AssetDefinition, AssetDefinitionId, AssetId, AssetValue},
     block::{BlockHeader, SignedBlock},
-    domain::Domain,
+    domain::{Domain, DomainId},
+    metadata::Metadata,
+    name::Name,
     parameter::{Parameter, Parameters},
     peer::PeerId,
     permission::Permission,
@@ -36,8 +38,8 @@ use crate::{
 };
 
 pub mod builder;
+pub mod dsl;
 pub mod parameters;
-pub mod predicate;
 
 /// A query that either returns a single value or errors out
 // NOTE: we are planning to remove this class of queries (https://github.com/hyperledger-iroha/iroha/issues/4933)
@@ -53,30 +55,39 @@ pub trait SingularQuery: Sealed {
 /// [`builder::QueryIterator`] abstracts over this and allows the query consumer to use a familiar [`Iterator`] interface to iterate over the results.
 pub trait Query: Sealed {
     /// The type of single element of the output collection
-    type Item: HasPredicateBox;
+    type Item: HasProjection<PredicateMarker> + HasProjection<SelectorMarker, AtomType = ()>;
 }
 
 #[model]
 mod model {
+    use derive_where::derive_where;
     use getset::Getters;
     use iroha_crypto::HashOf;
+    use iroha_macro::serde_where;
 
     use super::*;
 
     /// An iterable query bundled with a filter
-    ///
-    /// The `P` type doesn't have any bounds to simplify generic trait bounds in some places.
-    /// Use [`super::QueryWithFilterFor`] if you have a concrete query type to avoid specifying `P` manually.
-    #[derive(
-        Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema, Constructor,
+    #[serde_where(Q, CompoundPredicate<Q::Item>, SelectorTuple<Q::Item>)]
+    #[derive_where(
+        Debug, Clone, PartialEq, Eq; Q, CompoundPredicate<Q::Item>, SelectorTuple<Q::Item>
     )]
-    pub struct QueryWithFilter<Q, P> {
+    #[derive(Decode, Encode, Constructor, IntoSchema, Deserialize, Serialize)]
+    pub struct QueryWithFilter<Q>
+    where
+        Q: Query,
+    {
         pub query: Q,
         #[serde(default = "predicate_default")]
-        pub predicate: CompoundPredicate<P>,
+        pub predicate: CompoundPredicate<Q::Item>,
+        #[serde(default)]
+        pub selector: SelectorTuple<Q::Item>,
     }
 
-    fn predicate_default<P>() -> CompoundPredicate<P> {
+    fn predicate_default<T>() -> CompoundPredicate<T>
+    where
+        T: HasProjection<PredicateMarker>,
+    {
         CompoundPredicate::PASS
     }
 
@@ -85,23 +96,23 @@ mod model {
         Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema, FromVariant,
     )]
     pub enum QueryBox {
-        FindDomains(QueryWithFilterFor<FindDomains>),
-        FindAccounts(QueryWithFilterFor<FindAccounts>),
-        FindAssets(QueryWithFilterFor<FindAssets>),
-        FindAssetsDefinitions(QueryWithFilterFor<FindAssetsDefinitions>),
-        FindRoles(QueryWithFilterFor<FindRoles>),
-
-        FindRoleIds(QueryWithFilterFor<FindRoleIds>),
-        FindPermissionsByAccountId(QueryWithFilterFor<FindPermissionsByAccountId>),
-        FindRolesByAccountId(QueryWithFilterFor<FindRolesByAccountId>),
-        FindAccountsWithAsset(QueryWithFilterFor<FindAccountsWithAsset>),
-
-        FindPeers(QueryWithFilterFor<FindPeers>),
-        FindActiveTriggerIds(QueryWithFilterFor<FindActiveTriggerIds>),
-        FindTriggers(QueryWithFilterFor<FindTriggers>),
-        FindTransactions(QueryWithFilterFor<FindTransactions>),
-        FindBlocks(QueryWithFilterFor<FindBlocks>),
-        FindBlockHeaders(QueryWithFilterFor<FindBlockHeaders>),
+        FindDomains(QueryWithFilter<FindDomains>),
+        FindAccounts(QueryWithFilter<FindAccounts>),
+        FindAssets(QueryWithFilter<FindAssets>),
+        FindAssetsDefinitions(QueryWithFilter<FindAssetsDefinitions>),
+        FindRoles(QueryWithFilter<FindRoles>),
+
+        FindRoleIds(QueryWithFilter<FindRoleIds>),
+        FindPermissionsByAccountId(QueryWithFilter<FindPermissionsByAccountId>),
+        FindRolesByAccountId(QueryWithFilter<FindRolesByAccountId>),
+        FindAccountsWithAsset(QueryWithFilter<FindAccountsWithAsset>),
+
+        FindPeers(QueryWithFilter<FindPeers>),
+        FindActiveTriggerIds(QueryWithFilter<FindActiveTriggerIds>),
+        FindTriggers(QueryWithFilter<FindTriggers>),
+        FindTransactions(QueryWithFilter<FindTransactions>),
+        FindBlocks(QueryWithFilter<FindBlocks>),
+        FindBlockHeaders(QueryWithFilter<FindBlockHeaders>),
     }
 
     /// An enum of all possible iterable query batches.
@@ -111,20 +122,38 @@ mod model {
         Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema, FromVariant,
     )]
     pub enum QueryOutputBatchBox {
+        PublicKey(Vec<PublicKey>),
+        String(Vec<String>),
+        Metadata(Vec<Metadata>),
+        Name(Vec<Name>),
+        DomainId(Vec<DomainId>),
         Domain(Vec<Domain>),
+        AccountId(Vec<AccountId>),
         Account(Vec<Account>),
+        AssetId(Vec<AssetId>),
         Asset(Vec<Asset>),
+        AssetValue(Vec<AssetValue>),
+        AssetDefinitionId(Vec<AssetDefinitionId>),
         AssetDefinition(Vec<AssetDefinition>),
         Role(Vec<Role>),
         Parameter(Vec<Parameter>),
         Permission(Vec<Permission>),
-        Transaction(Vec<CommittedTransaction>),
+        CommittedTransaction(Vec<CommittedTransaction>),
+        SignedTransaction(Vec<SignedTransaction>),
+        TransactionHash(Vec<HashOf<SignedTransaction>>),
+        TransactionRejectionReason(Vec<Option<TransactionRejectionReason>>),
         Peer(Vec<PeerId>),
         RoleId(Vec<RoleId>),
         TriggerId(Vec<TriggerId>),
         Trigger(Vec<Trigger>),
         Block(Vec<SignedBlock>),
         BlockHeader(Vec<BlockHeader>),
+        BlockHeaderHash(Vec<HashOf<BlockHeader>>),
+    }
+
+    #[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
+    pub struct QueryOutputBatchBoxTuple {
+        pub tuple: Vec<QueryOutputBatchBox>,
     }
 
     /// An enum of all possible singular queries
@@ -161,7 +190,7 @@ mod model {
     #[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
     pub struct QueryOutput {
         /// A single batch of results
-        pub batch: QueryOutputBatchBox,
+        pub batch: QueryOutputBatchBoxTuple,
         /// The number of items in the query remaining to be fetched after this batch
         pub remaining_items: u64,
         /// If not `None`, contains a cursor that can be used to fetch the next batch of results. Otherwise the current batch is the last one.
@@ -251,10 +280,6 @@ mod model {
     }
 }
 
-/// A type alias to refer to a [`QueryWithFilter`] paired with a correct predicate
-pub type QueryWithFilterFor<Q> =
-    QueryWithFilter<Q, <<Q as Query>::Item as HasPredicateBox>::PredicateBoxType>;
-
 impl QueryOutputBatchBox {
     // this is used in client cli to do type-erased iterable queries
     /// Extends this batch with another batch of the same type
@@ -264,20 +289,35 @@ impl QueryOutputBatchBox {
     /// Panics if the types of the two batches do not match
     pub fn extend(&mut self, other: QueryOutputBatchBox) {
         match (self, other) {
+            (Self::PublicKey(v1), Self::PublicKey(v2)) => v1.extend(v2),
+            (Self::String(v1), Self::String(v2)) => v1.extend(v2),
+            (Self::Metadata(v1), Self::Metadata(v2)) => v1.extend(v2),
+            (Self::Name(v1), Self::Name(v2)) => v1.extend(v2),
+            (Self::DomainId(v1), Self::DomainId(v2)) => v1.extend(v2),
             (Self::Domain(v1), Self::Domain(v2)) => v1.extend(v2),
+            (Self::AccountId(v1), Self::AccountId(v2)) => v1.extend(v2),
             (Self::Account(v1), Self::Account(v2)) => v1.extend(v2),
+            (Self::AssetId(v1), Self::AssetId(v2)) => v1.extend(v2),
             (Self::Asset(v1), Self::Asset(v2)) => v1.extend(v2),
+            (Self::AssetValue(v1), Self::AssetValue(v2)) => v1.extend(v2),
+            (Self::AssetDefinitionId(v1), Self::AssetDefinitionId(v2)) => v1.extend(v2),
             (Self::AssetDefinition(v1), Self::AssetDefinition(v2)) => v1.extend(v2),
             (Self::Role(v1), Self::Role(v2)) => v1.extend(v2),
             (Self::Parameter(v1), Self::Parameter(v2)) => v1.extend(v2),
             (Self::Permission(v1), Self::Permission(v2)) => v1.extend(v2),
-            (Self::Transaction(v1), Self::Transaction(v2)) => v1.extend(v2),
+            (Self::CommittedTransaction(v1), Self::CommittedTransaction(v2)) => v1.extend(v2),
+            (Self::SignedTransaction(v1), Self::SignedTransaction(v2)) => v1.extend(v2),
+            (Self::TransactionHash(v1), Self::TransactionHash(v2)) => v1.extend(v2),
+            (Self::TransactionRejectionReason(v1), Self::TransactionRejectionReason(v2)) => {
+                v1.extend(v2)
+            }
             (Self::Peer(v1), Self::Peer(v2)) => v1.extend(v2),
             (Self::RoleId(v1), Self::RoleId(v2)) => v1.extend(v2),
             (Self::TriggerId(v1), Self::TriggerId(v2)) => v1.extend(v2),
             (Self::Trigger(v1), Self::Trigger(v2)) => v1.extend(v2),
             (Self::Block(v1), Self::Block(v2)) => v1.extend(v2),
             (Self::BlockHeader(v1), Self::BlockHeader(v2)) => v1.extend(v2),
+            (Self::BlockHeaderHash(v1), Self::BlockHeaderHash(v2)) => v1.extend(v2),
             _ => panic!("Cannot extend different types of IterableQueryOutputBatchBox"),
         }
     }
@@ -286,24 +326,71 @@ impl QueryOutputBatchBox {
     #[allow(clippy::len_without_is_empty)] // having a len without `is_empty` is fine, we don't return empty batches
     pub fn len(&self) -> usize {
         match self {
+            Self::PublicKey(v) => v.len(),
+            Self::String(v) => v.len(),
+            Self::Metadata(v) => v.len(),
+            Self::Name(v) => v.len(),
+            Self::DomainId(v) => v.len(),
             Self::Domain(v) => v.len(),
+            Self::AccountId(v) => v.len(),
             Self::Account(v) => v.len(),
+            Self::AssetId(v) => v.len(),
             Self::Asset(v) => v.len(),
+            Self::AssetValue(v) => v.len(),
+            Self::AssetDefinitionId(v) => v.len(),
             Self::AssetDefinition(v) => v.len(),
             Self::Role(v) => v.len(),
             Self::Parameter(v) => v.len(),
             Self::Permission(v) => v.len(),
-            Self::Transaction(v) => v.len(),
+            Self::CommittedTransaction(v) => v.len(),
+            Self::SignedTransaction(v) => v.len(),
+            Self::TransactionHash(v) => v.len(),
+            Self::TransactionRejectionReason(v) => v.len(),
             Self::Peer(v) => v.len(),
             Self::RoleId(v) => v.len(),
             Self::TriggerId(v) => v.len(),
             Self::Trigger(v) => v.len(),
             Self::Block(v) => v.len(),
             Self::BlockHeader(v) => v.len(),
+            Self::BlockHeaderHash(v) => v.len(),
         }
     }
 }
 
+impl QueryOutputBatchBoxTuple {
+    /// Extends this batch tuple with another batch tuple of the same type
+    ///
+    /// # Panics
+    ///
+    /// Panics if the types or lengths of the two batche tuples do not match
+    pub fn extend(&mut self, other: Self) {
+        if self.tuple.len() != other.tuple.len() {
+            panic!("Cannot extend QueryOutputBatchBoxTuple with different number of elements");
+        }
+
+        self.tuple
+            .iter_mut()
+            .zip(other.tuple.into_iter())
+            .for_each(|(self_batch, other_batch)| self_batch.extend(other_batch));
+    }
+
+    /// Returns length of this batch tuple
+    // This works under assumption that all batches in the tuples have the same length, which should be true for iroha
+    pub fn len(&self) -> usize {
+        self.tuple[0].len()
+    }
+
+    /// Returns an iterator over the batches in this tuple
+    pub fn iter(&self) -> impl Iterator<Item = &QueryOutputBatchBox> {
+        self.tuple.iter()
+    }
+
+    /// Consumes this batch tuple and returns an iterator over the batches
+    pub fn into_iter(self) -> impl Iterator<Item = QueryOutputBatchBox> {
+        self.tuple.into_iter()
+    }
+}
+
 impl SingularQuery for SingularQueryBox {
     type Output = SingularQueryOutputBox;
 }
@@ -311,7 +398,7 @@ impl SingularQuery for SingularQueryBox {
 impl QueryOutput {
     /// Create a new [`QueryOutput`] from the iroha response parts.
     pub fn new(
-        batch: QueryOutputBatchBox,
+        batch: QueryOutputBatchBoxTuple,
         remaining_items: u64,
         continue_cursor: Option<ForwardCursor>,
     ) -> Self {
@@ -323,7 +410,7 @@ impl QueryOutput {
     }
 
     /// Split this [`QueryOutput`] into its constituent parts.
-    pub fn into_parts(self) -> (QueryOutputBatchBox, u64, Option<ForwardCursor>) {
+    pub fn into_parts(self) -> (QueryOutputBatchBoxTuple, u64, Option<ForwardCursor>) {
         (self.batch, self.remaining_items, self.continue_cursor)
     }
 }
@@ -1097,8 +1184,8 @@ pub mod error {
 pub mod prelude {
     pub use super::{
         account::prelude::*, asset::prelude::*, block::prelude::*, builder::prelude::*,
-        domain::prelude::*, executor::prelude::*, parameters::prelude::*, peer::prelude::*,
-        permission::prelude::*, predicate::prelude::*, role::prelude::*, transaction::prelude::*,
+        domain::prelude::*, dsl::prelude::*, executor::prelude::*, parameters::prelude::*,
+        peer::prelude::*, permission::prelude::*, role::prelude::*, transaction::prelude::*,
         trigger::prelude::*, CommittedTransaction, QueryBox, QueryRequest, SingularQueryBox,
     };
 }
diff --git a/crates/iroha_data_model/src/query/predicate/mod.rs b/crates/iroha_data_model/src/query/predicate/mod.rs
deleted file mode 100644
index d9e77669afe..00000000000
--- a/crates/iroha_data_model/src/query/predicate/mod.rs
+++ /dev/null
@@ -1,370 +0,0 @@
-//! Contain definitions of predicates for different types and a DSL to build them.
-//!
-//! # Implementation details of the predicate DSL
-//!
-//! There are three main components to the predicate DSL:
-//! - Prototypes
-//! - Projectors
-//! - Atomic predicates and combinators
-//!
-//! Prototype is a structure that mimics an object the predicate is being built on.
-//! You can call methods on it to build predicate directly (like [`prototypes::account::AccountIdPrototype::eq`]) or access one of its fields, which are all prototypes of the elements of the object (like `account_id.domain_id`).
-//!
-//! Projectors are needed for inner elements of prototypes to remember the object they are part of, so that `account_id.domain_id` would still build `AccountIdPredicateBox`es, while still being an `DomainIdPrototype`.
-//!
-//! This is achieved by passing an implementation of [`projectors::ObjectProjector`] trait to the prototype. An object projector accepts a predicate of a more specific type and returns a predicate of a more general type wrapped in a projection.
-//!
-//! For example, `AccountIdDomainIdProjector` accepts a predicate on `DomainId` makes a predicate on `AccountId` by wrapping it with `AccountIdDomainIdProjection`. Notice the difference between projector and projection: projector is just an utility type, while projection is a predicate.
-//!
-//! ## Predicate combinators and normalization
-//!
-//! There are also two representations of the predicates:
-//! - Normalized representation, which is designed for serialization and evaluation
-//! - AST representation, which is designed for type-checking and easy & efficient composition
-//!
-//! Normalized representation consists of [`CompoundPredicate<T>`], with `T` being an atomic predicate box for that type (like [`predicate_atoms::account::AccountIdPredicateBox`]).
-//! The [`CompoundPredicate`] layer implements logical operators on top of the atomic predicate, while the projections are handled with the atomic predicate itself, with variants like [`predicate_atoms::account::AccountIdPredicateBox::DomainId`].
-//!
-//! Normalized representation aims to reduce the number of types not to bloat the schema and reduce redundancy.
-//!
-//! Predicates in the normalized representation can be evaluated using the [`EvaluatePredicate`] trait.
-//!
-//! Ast predicates are more numerous: they include atomic predicates (like [`predicate_atoms::account::AccountIdPredicateBox`]), logical combinators (three types in [`predicate_combinators`]), and projections (like [`projectors::AccountIdDomainIdProjection`]).
-//!
-//! Ast predicates implement [`AstPredicate<T>`] the trait with `T` being the atomic predicate box they normalize into.
-//! The [`AstPredicate<T>`] defines the logic for converting the AST into the normalized representation.
-
-pub mod predicate_ast_extensions;
-pub mod predicate_atoms;
-pub mod predicate_combinators;
-pub mod projectors;
-pub mod prototypes;
-
-#[cfg(not(feature = "std"))]
-use alloc::{boxed::Box, vec, vec::Vec};
-
-use super::*;
-
-/// Trait defining how to apply a predicate to a value `T`.
-pub trait EvaluatePredicate<T: ?Sized> {
-    /// The result of applying the predicate to a value.
-    fn applies(&self, input: &T) -> bool;
-}
-
-/// A predicate combinator adding support for logical operations on some atomic (basis) predicate type.
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum CompoundPredicate<Atom> {
-    /// An atomic predicate as-is.
-    Atom(Atom),
-    /// A negation of a compound predicate.
-    Not(Box<Self>),
-    /// A conjunction of multiple predicates.
-    And(Vec<Self>),
-    /// A disjunction of multiple predicates.
-    Or(Vec<Self>),
-}
-
-impl<Atom> CompoundPredicate<Atom> {
-    /// A compound predicate that always evaluates to `true`.
-    pub const PASS: Self = Self::And(Vec::new());
-    /// A compound predicate that always evaluates to `false`.
-    pub const FAIL: Self = Self::Or(Vec::new());
-
-    /// Negate the predicate.
-    #[allow(clippy::should_implement_trait)]
-    // not implementing std::ops::Not, because
-    // - don't need it used as an overloaded operator (most of this happens with AST predicates)
-    // - making this symmetric with `and` and `or` would require renaming them to `bitand` and `bitor` which is a downgrade IMO
-    #[must_use]
-    pub fn not(self) -> Self {
-        match self {
-            // if the top-level predicate is a negation, we can just remove it
-            CompoundPredicate::Not(expr) => *expr,
-            this => CompoundPredicate::Not(Box::new(this)),
-        }
-    }
-
-    /// Combine two predicates with an "and" operation.
-    #[must_use]
-    pub fn and(self, other: Self) -> Self {
-        match (self, other) {
-            // if any of the predicates is an and - flatten it
-            (CompoundPredicate::And(mut and_list), other) => {
-                and_list.push(other);
-                CompoundPredicate::And(and_list)
-            }
-            (this, CompoundPredicate::And(mut and_list)) => {
-                // push to front to preserve user-specified order (our predicates are short-circuiting)
-                and_list.insert(0, this);
-                CompoundPredicate::And(and_list)
-            }
-            (this, other) => CompoundPredicate::And(vec![this, other]),
-        }
-    }
-
-    /// Combine two predicates with an "or" operation.
-    #[must_use]
-    pub fn or(self, other: Self) -> Self {
-        match (self, other) {
-            // if any of the predicates is an or - flatten it
-            (CompoundPredicate::Or(mut or_list), other) => {
-                or_list.push(other);
-                CompoundPredicate::Or(or_list)
-            }
-            (this, CompoundPredicate::Or(mut or_list)) => {
-                // push to front to preserve user-specified order (our predicates are short-circuiting)
-                or_list.insert(0, this);
-                CompoundPredicate::Or(or_list)
-            }
-            (this, other) => CompoundPredicate::Or(vec![this, other]),
-        }
-    }
-}
-
-/// A marker trait allowing to associate a predicate box type corresponding to the type.
-pub trait HasPredicateBox {
-    /// The type of the atomic predicate corresponding to the type.
-    type PredicateBoxType: EvaluatePredicate<Self>;
-}
-
-/// A marker trait allowing to get a type of prototype for the type.
-///
-/// Not that it is implemented on predicate, not on concrete types. That is because some predicates, like [`predicate_atoms::StringPredicateBox`] are applicable to multiple types.
-pub trait HasPrototype {
-    /// Get a prototype for the predicate, with the given projector.
-    type Prototype<Projector: Default>: Default;
-}
-
-impl<T, Atom> EvaluatePredicate<T> for CompoundPredicate<Atom>
-where
-    Atom: EvaluatePredicate<T>,
-{
-    fn applies(&self, input: &T) -> bool {
-        match self {
-            CompoundPredicate::Atom(atom) => atom.applies(input),
-            CompoundPredicate::Not(expr) => !expr.applies(input),
-            CompoundPredicate::And(exprs) => exprs.iter().all(|expr| expr.applies(input)),
-            CompoundPredicate::Or(exprs) => exprs.iter().any(|expr| expr.applies(input)),
-        }
-    }
-}
-
-/// Trait that marks a predicate in AST representation. The `PredType` generic parameters defines the type of the atomic predicate this predicate normalizes into.
-///
-/// The main task is to facilitate normalization:
-/// the extraction of all logical combinators ("not", "and" and "or") to the outer scope,
-/// leaving only projections as "atomic" predicates
-pub trait AstPredicate<PredType> {
-    /// Normalize the predicate, applying `proj` to every atomic predicate emitted.
-    fn normalize_with_proj<OutputType, Proj>(self, proj: Proj) -> CompoundPredicate<OutputType>
-    where
-        Proj: Fn(PredType) -> OutputType + Copy;
-}
-
-pub mod prelude {
-    //! Re-export important types and traits for glob import `(::*)`
-    pub use super::{predicate_atoms::prelude::*, CompoundPredicate, EvaluatePredicate};
-}
-
-#[cfg(test)]
-mod test {
-    use iroha_crypto::PublicKey;
-
-    use crate::{
-        account::AccountId,
-        asset::AssetId,
-        domain::DomainId,
-        prelude::{AssetDefinitionIdPredicateBox, AssetIdPredicateBox, StringPredicateBox},
-        query::predicate::{
-            predicate_ast_extensions::AstPredicateExt as _,
-            predicate_atoms::{
-                account::{AccountIdPredicateBox, AccountPredicateBox},
-                domain::DomainIdPredicateBox,
-                PublicKeyPredicateBox,
-            },
-            projectors::BaseProjector,
-            prototypes::account::AccountPrototype,
-            CompoundPredicate,
-        },
-    };
-
-    /// Smoke test that creates a simple predicate using a prototype
-    #[test]
-    fn test_prototype_api() {
-        let alice_account_id: AccountId =
-            "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland"
-                .parse()
-                .unwrap();
-
-        // construct a prototype (done by the machinery)
-        let account = AccountPrototype::<BaseProjector<AccountPredicateBox>>::default();
-        // take a look at the type name (it should be `AccountIdPrototype<AccountIdProjector<BaseProjector<AccountPredicateBox>>>`)
-        #[allow(unused)]
-        let account_id_prototype = account.id;
-        // make a predicate from it (done by the user)
-        let predicate = account.id.eq(alice_account_id.clone());
-        // normalize it (done by the machinery)
-        let predicate_norm = predicate.normalize();
-
-        // check that the predicate is correct
-        assert_eq!(
-            predicate_norm,
-            CompoundPredicate::Atom(AccountPredicateBox::Id(AccountIdPredicateBox::Equals(
-                alice_account_id
-            )))
-        );
-    }
-
-    /// Same as [`test_prototype_api`], but uses the `AccountPredicateBox::build()` method
-    #[test]
-    fn test_builder_api() {
-        let alice_account_id: AccountId =
-            "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland"
-                .parse()
-                .unwrap();
-
-        let predicate_norm =
-            AccountPredicateBox::build(|account| account.id.eq(alice_account_id.clone()));
-
-        // check that the predicate is correct
-        assert_eq!(
-            predicate_norm,
-            CompoundPredicate::Atom(AccountPredicateBox::Id(AccountIdPredicateBox::Equals(
-                alice_account_id
-            )))
-        );
-    }
-
-    /// Create a denormalized predicate (logical combinator inside a projection), check that it normalizes correctly
-    #[test]
-    fn test_prototype_normalization() {
-        let alice_signatory: PublicKey =
-            "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03"
-                .parse()
-                .unwrap();
-        let alice_domain_id: DomainId = "wonderland".parse().unwrap();
-
-        let account_predicate_denorm = AccountPredicateBox::build_fragment(|account| {
-            let account_id_predicate = AccountIdPredicateBox::build_fragment(|account_id| {
-                account_id
-                    .signatory
-                    .eq(alice_signatory.clone())
-                    .and(account_id.domain_id.eq(alice_domain_id.clone()))
-            });
-
-            // note that we use a non-normalized predicate, built with `build_fragment`
-            account.id.satisfies(account_id_predicate)
-        });
-        let account_predicate = account_predicate_denorm.normalize();
-
-        // check that the predicate is correct
-        assert_eq!(
-            account_predicate,
-            CompoundPredicate::And(vec![
-                CompoundPredicate::Atom(AccountPredicateBox::Id(AccountIdPredicateBox::Signatory(
-                    PublicKeyPredicateBox::Equals(alice_signatory)
-                ))),
-                CompoundPredicate::Atom(AccountPredicateBox::Id(AccountIdPredicateBox::DomainId(
-                    DomainIdPredicateBox::Equals(alice_domain_id)
-                )))
-            ])
-        );
-    }
-
-    /// Tests operator overloading shorthand combinators for various cases
-    #[test]
-    fn test_operator_overloading() {
-        let asset_id1: AssetId = "xor##ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland".parse().unwrap();
-        let asset_id2: AssetId = "rose##ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland".parse().unwrap();
-
-        let asset_predicate = AssetIdPredicateBox::build(|id| {
-            // DSL uses `|` and `&` operators, even though the actual logic is short-circuiting internally.
-            // this is because `||` and `&&` are not overloadable in Rust
-
-            // check that operator overloading works on atomic predicates
-            let or_predicate1 = id.eq(asset_id1.clone()) | id.eq(asset_id2.clone());
-
-            // check that operator overloading works on projection predicates
-            let or_predicate2 = id.definition_id.name.starts_with("xor")
-                | id.account.domain_id.eq("wonderland".parse().unwrap());
-
-            // check that operator overloading works on predicate combinators
-            or_predicate1 & or_predicate2
-        });
-
-        assert_eq!(
-            asset_predicate,
-            CompoundPredicate::And(vec![
-                CompoundPredicate::Or(vec![
-                    CompoundPredicate::Atom(AssetIdPredicateBox::Equals(asset_id1)),
-                    CompoundPredicate::Atom(AssetIdPredicateBox::Equals(asset_id2)),
-                ]),
-                CompoundPredicate::Or(vec![
-                    CompoundPredicate::Atom(AssetIdPredicateBox::DefinitionId(
-                        AssetDefinitionIdPredicateBox::Name(StringPredicateBox::StartsWith(
-                            "xor".to_string()
-                        ))
-                    )),
-                    CompoundPredicate::Atom(AssetIdPredicateBox::AccountId(
-                        AccountIdPredicateBox::DomainId(DomainIdPredicateBox::Equals(
-                            "wonderland".parse().unwrap()
-                        ))
-                    )),
-                ]),
-            ])
-        );
-    }
-
-    #[test]
-    fn test_flattening() {
-        // check `and` flattening
-        let right_assoc = StringPredicateBox::build(|s| {
-            s.starts_with("a") & (s.ends_with("b") & s.ends_with("c"))
-        });
-        let left_assoc = StringPredicateBox::build(|s| {
-            (s.starts_with("a") & s.ends_with("b")) & s.ends_with("c")
-        });
-
-        // the user ordering should be preserved, to mimic the short-circuiting behavior of `&&`
-        assert_eq!(right_assoc, left_assoc);
-
-        // the predicates should get flattened
-        assert_eq!(
-            right_assoc,
-            CompoundPredicate::And(vec![
-                CompoundPredicate::Atom(StringPredicateBox::StartsWith("a".to_string())),
-                CompoundPredicate::Atom(StringPredicateBox::EndsWith("b".to_string())),
-                CompoundPredicate::Atom(StringPredicateBox::EndsWith("c".to_string())),
-            ])
-        );
-
-        // check the same for `or`
-        let right_assoc = StringPredicateBox::build(|s| {
-            s.starts_with("a") | (s.ends_with("b") | s.ends_with("c"))
-        });
-        let left_assoc = StringPredicateBox::build(|s| {
-            (s.starts_with("a") | s.ends_with("b")) | s.ends_with("c")
-        });
-
-        // the user ordering should be preserved, to mimic the short-circuiting behavior of `||`
-        assert_eq!(right_assoc, left_assoc);
-
-        // the predicates should get flattened
-        assert_eq!(
-            right_assoc,
-            CompoundPredicate::Or(vec![
-                CompoundPredicate::Atom(StringPredicateBox::StartsWith("a".to_string())),
-                CompoundPredicate::Atom(StringPredicateBox::EndsWith("b".to_string())),
-                CompoundPredicate::Atom(StringPredicateBox::EndsWith("c".to_string())),
-            ])
-        );
-
-        // check `not` flattening
-        let not_flat = StringPredicateBox::build(|s| !!s.starts_with("a"));
-
-        assert_eq!(
-            not_flat,
-            CompoundPredicate::Atom(StringPredicateBox::StartsWith("a".to_string()))
-        );
-    }
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_ast_extensions.rs b/crates/iroha_data_model/src/query/predicate/predicate_ast_extensions.rs
deleted file mode 100644
index 1c17d09690c..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_ast_extensions.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! A module providing extensions to the [`AstPredicate`] trait.
-
-use super::{AstPredicate, CompoundPredicate};
-use crate::query::predicate::predicate_combinators::{
-    AndAstPredicate, NotAstPredicate, OrAstPredicate,
-};
-
-/// Extension trait for [`AstPredicate`].
-pub trait AstPredicateExt<PredType>: AstPredicate<PredType>
-where
-    Self: Sized,
-{
-    /// Normalize this predicate without applying additional projections.
-    fn normalize(self) -> CompoundPredicate<PredType> {
-        self.normalize_with_proj(|p| p)
-    }
-
-    /// Negate this AST predicate.
-    fn not(self) -> NotAstPredicate<Self> {
-        NotAstPredicate(self)
-    }
-
-    /// Combine this AST predicate with another AST predicate using logical AND.
-    fn and<PLhs>(self, other: PLhs) -> AndAstPredicate<Self, PLhs>
-    where
-        PLhs: AstPredicate<PredType>,
-    {
-        AndAstPredicate(self, other)
-    }
-
-    /// Combine this AST predicate with another AST predicate using logical OR.
-    fn or<PLhs>(self, other: PLhs) -> OrAstPredicate<Self, PLhs>
-    where
-        PLhs: AstPredicate<PredType>,
-    {
-        OrAstPredicate(self, other)
-    }
-}
-
-impl<PredType, P> AstPredicateExt<PredType> for P where P: AstPredicate<PredType> {}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/account.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/account.rs
deleted file mode 100644
index 6a77d6182b9..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/account.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//! This module contains predicates for account-related objects, mirroring [`crate::account`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use iroha_version::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    account::{Account, AccountId},
-    query::{
-        predicate::{
-            predicate_ast_extensions::AstPredicateExt as _,
-            predicate_atoms::{
-                domain::DomainIdPredicateBox, MetadataPredicateBox, PublicKeyPredicateBox,
-            },
-            predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-            projectors::BaseProjector,
-            EvaluatePredicate,
-        },
-        AstPredicate, CompoundPredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to an [`AccountId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum AccountIdPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(AccountId),
-    // projections
-    /// Checks if a predicate applies to the domain ID of the input.
-    DomainId(DomainIdPredicateBox),
-    /// Checks if a predicate applies to the signatory of the input.
-    Signatory(PublicKeyPredicateBox),
-}
-
-impl_predicate_box!(AccountId: AccountIdPredicateBox);
-
-impl EvaluatePredicate<AccountId> for AccountIdPredicateBox {
-    fn applies(&self, input: &AccountId) -> bool {
-        match self {
-            AccountIdPredicateBox::Equals(expected) => expected == input,
-            AccountIdPredicateBox::DomainId(domain) => domain.applies(&input.domain),
-            AccountIdPredicateBox::Signatory(public_key) => public_key.applies(&input.signatory),
-        }
-    }
-}
-
-/// A predicate that can be applied to an [`Account`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-#[allow(unreachable_patterns)]
-pub enum AccountPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the ID of the input.
-    Id(AccountIdPredicateBox),
-    /// Checks if a predicate applies to the metadata of the input.
-    Metadata(MetadataPredicateBox),
-}
-
-impl_predicate_box!(Account: AccountPredicateBox);
-
-impl EvaluatePredicate<Account> for AccountPredicateBox {
-    fn applies(&self, input: &Account) -> bool {
-        match self {
-            AccountPredicateBox::Id(id) => id.applies(&input.id),
-            AccountPredicateBox::Metadata(metadata) => metadata.applies(&input.metadata),
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{AccountIdPredicateBox, AccountPredicateBox};
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/asset.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/asset.rs
deleted file mode 100644
index 60f80883728..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/asset.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-//! This module contains predicates for asset-related objects, mirroring [`crate::asset`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use iroha_version::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    asset::{Asset, AssetDefinition, AssetDefinitionId, AssetId, AssetValue},
-    query::{
-        predicate::{
-            predicate_ast_extensions::AstPredicateExt as _,
-            predicate_atoms::{
-                account::AccountIdPredicateBox, domain::DomainIdPredicateBox, MetadataPredicateBox,
-                StringPredicateBox,
-            },
-            predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-            projectors::BaseProjector,
-            EvaluatePredicate,
-        },
-        AstPredicate, CompoundPredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to an [`AssetDefinitionId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-#[allow(unreachable_patterns)]
-pub enum AssetDefinitionPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the ID of the input.
-    Id(AssetDefinitionIdPredicateBox),
-    /// Checks if a predicate applies to the metadata of the input.
-    Metadata(MetadataPredicateBox),
-    /// Checks if a predicate applies to the owner of the input.
-    OwnedBy(AccountIdPredicateBox),
-}
-
-impl_predicate_box!(AssetDefinition: AssetDefinitionPredicateBox);
-
-impl EvaluatePredicate<AssetDefinition> for AssetDefinitionPredicateBox {
-    fn applies(&self, input: &AssetDefinition) -> bool {
-        match self {
-            AssetDefinitionPredicateBox::Id(id) => id.applies(&input.id),
-            AssetDefinitionPredicateBox::Metadata(metadata) => metadata.applies(&input.metadata),
-            AssetDefinitionPredicateBox::OwnedBy(account_id) => account_id.applies(&input.owned_by),
-        }
-    }
-}
-
-/// A predicate that can be applied to an [`Asset`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-#[allow(unreachable_patterns)]
-pub enum AssetPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the ID of the input.
-    Id(AssetIdPredicateBox),
-    /// Checks if a predicate applies to the value of the input.
-    Value(AssetValuePredicateBox),
-}
-
-impl_predicate_box!(Asset: AssetPredicateBox);
-
-impl EvaluatePredicate<Asset> for AssetPredicateBox {
-    fn applies(&self, input: &Asset) -> bool {
-        match self {
-            AssetPredicateBox::Id(id) => id.applies(&input.id),
-            AssetPredicateBox::Value(value) => value.applies(&input.value),
-        }
-    }
-}
-
-/// A predicate that can be applied to an [`AssetValue`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum AssetValuePredicateBox {
-    // TODO: populate
-    // FIX: Remove all `#[allow(unreachable_patterns)]` from all use sites
-    // once some variants are added into this enum
-}
-
-impl_predicate_box!(AssetValue: AssetValuePredicateBox);
-
-impl EvaluatePredicate<AssetValue> for AssetValuePredicateBox {
-    fn applies(&self, _input: &AssetValue) -> bool {
-        match *self {}
-    }
-}
-
-/// A predicate that can be applied to an [`AssetId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum AssetIdPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(AssetId),
-    // projections
-    /// Checks if a predicate applies to the definition ID of the input.
-    DefinitionId(AssetDefinitionIdPredicateBox),
-    /// Checks if a predicate applies to the account ID of the input.
-    AccountId(AccountIdPredicateBox),
-}
-
-impl_predicate_box!(AssetId: AssetIdPredicateBox);
-
-impl EvaluatePredicate<AssetId> for AssetIdPredicateBox {
-    fn applies(&self, input: &AssetId) -> bool {
-        match self {
-            AssetIdPredicateBox::Equals(expected) => expected == input,
-            AssetIdPredicateBox::DefinitionId(definition_id) => {
-                definition_id.applies(&input.definition)
-            }
-            AssetIdPredicateBox::AccountId(account_id) => account_id.applies(&input.account),
-        }
-    }
-}
-
-/// A predicate that can be applied to an [`AssetDefinitionId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum AssetDefinitionIdPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(AssetDefinitionId),
-    // projections
-    /// Checks if a predicate applies to the domain ID of the input.
-    DomainId(DomainIdPredicateBox),
-    /// Checks if a predicate applies to the name of the input.
-    Name(StringPredicateBox),
-}
-
-impl_predicate_box!(AssetDefinitionId: AssetDefinitionIdPredicateBox);
-
-impl EvaluatePredicate<AssetDefinitionId> for AssetDefinitionIdPredicateBox {
-    fn applies(&self, input: &AssetDefinitionId) -> bool {
-        match self {
-            AssetDefinitionIdPredicateBox::Equals(expected) => expected == input,
-            AssetDefinitionIdPredicateBox::DomainId(domain) => domain.applies(&input.domain),
-            AssetDefinitionIdPredicateBox::Name(name) => name.applies(&input.name),
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{
-        AssetDefinitionIdPredicateBox, AssetDefinitionPredicateBox, AssetIdPredicateBox,
-        AssetPredicateBox, AssetValuePredicateBox,
-    };
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/block.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/block.rs
deleted file mode 100644
index 1d26a8f5057..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/block.rs
+++ /dev/null
@@ -1,248 +0,0 @@
-//! This module contains predicates for block-related objects, mirroring [`crate::block`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_crypto::HashOf;
-use iroha_schema::IntoSchema;
-use parity_scale_codec::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    block::{BlockHeader, SignedBlock},
-    prelude::{AccountIdPredicateBox, TransactionRejectionReason},
-    query::{
-        predicate::{
-            predicate_ast_extensions::AstPredicateExt as _,
-            predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-            projectors::BaseProjector,
-            AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-        },
-        CommittedTransaction,
-    },
-    transaction::SignedTransaction,
-};
-
-/// A predicate that can be applied to a [`HashOf<BlockHeader>`]
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum BlockHashPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(HashOf<BlockHeader>),
-}
-
-impl_predicate_box!(HashOf<BlockHeader>: BlockHashPredicateBox);
-
-impl EvaluatePredicate<HashOf<BlockHeader>> for BlockHashPredicateBox {
-    fn applies(&self, input: &HashOf<BlockHeader>) -> bool {
-        match self {
-            BlockHashPredicateBox::Equals(hash) => input == hash,
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`BlockHeader`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum BlockHeaderPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the hash of the block header.
-    Hash(BlockHashPredicateBox),
-}
-
-impl_predicate_box!(BlockHeader: BlockHeaderPredicateBox);
-
-impl EvaluatePredicate<BlockHeader> for BlockHeaderPredicateBox {
-    fn applies(&self, input: &BlockHeader) -> bool {
-        match self {
-            BlockHeaderPredicateBox::Hash(hash) => hash.applies(&input.hash()),
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`SignedBlock`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum SignedBlockPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the header of the block.
-    Header(BlockHeaderPredicateBox),
-}
-
-impl_predicate_box!(SignedBlock: SignedBlockPredicateBox);
-
-impl EvaluatePredicate<SignedBlock> for SignedBlockPredicateBox {
-    fn applies(&self, input: &SignedBlock) -> bool {
-        match self {
-            SignedBlockPredicateBox::Header(header) => header.applies(&input.header()),
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`HashOf<SignedTransaction>`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum TransactionHashPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(HashOf<SignedTransaction>),
-}
-
-impl_predicate_box!(HashOf<SignedTransaction>: TransactionHashPredicateBox);
-
-impl EvaluatePredicate<HashOf<SignedTransaction>> for TransactionHashPredicateBox {
-    fn applies(&self, input: &HashOf<SignedTransaction>) -> bool {
-        match self {
-            TransactionHashPredicateBox::Equals(hash) => input == hash,
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`SignedTransaction`]
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum SignedTransactionPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the hash of the signed transaction.
-    Hash(TransactionHashPredicateBox),
-    /// Checks if a predicate applies to the authority of the signed transaction.
-    Authority(AccountIdPredicateBox),
-}
-
-impl_predicate_box!(SignedTransaction: SignedTransactionPredicateBox);
-
-impl EvaluatePredicate<SignedTransaction> for SignedTransactionPredicateBox {
-    fn applies(&self, input: &SignedTransaction) -> bool {
-        match self {
-            SignedTransactionPredicateBox::Hash(hash) => hash.applies(&input.hash()),
-            SignedTransactionPredicateBox::Authority(authority) => {
-                authority.applies(input.authority())
-            }
-        }
-    }
-}
-
-// TODO: maybe we would want to have a generic `Option` predicate box & predicate
-/// A predicate that can be applied to an [`Option<TransactionRejectionReason>`]
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum TransactionErrorPredicateBox {
-    // object-specific predicates
-    /// Checks if there was an error while applying the transaction.
-    IsSome,
-}
-
-impl_predicate_box!(Option<TransactionRejectionReason>: TransactionErrorPredicateBox);
-
-impl EvaluatePredicate<Option<TransactionRejectionReason>> for TransactionErrorPredicateBox {
-    fn applies(&self, input: &Option<TransactionRejectionReason>) -> bool {
-        match self {
-            TransactionErrorPredicateBox::IsSome => input.is_some(),
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`CommittedTransaction`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum CommittedTransactionPredicateBox {
-    /// Checks if a predicate applies to the hash of the block the transaction was included in.
-    BlockHash(BlockHashPredicateBox),
-    /// Checks if a predicate applies to the committed transaction inside.
-    Value(SignedTransactionPredicateBox),
-    /// Checks if a predicate applies to the error of the transaction.
-    Error(TransactionErrorPredicateBox),
-}
-
-impl_predicate_box!(CommittedTransaction: CommittedTransactionPredicateBox);
-
-impl EvaluatePredicate<CommittedTransaction> for CommittedTransactionPredicateBox {
-    fn applies(&self, input: &CommittedTransaction) -> bool {
-        match self {
-            CommittedTransactionPredicateBox::BlockHash(block_hash) => {
-                block_hash.applies(&input.block_hash)
-            }
-            CommittedTransactionPredicateBox::Value(committed_transaction) => {
-                committed_transaction.applies(&input.value)
-            }
-            CommittedTransactionPredicateBox::Error(error) => error.applies(&input.error),
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{
-        BlockHashPredicateBox, BlockHeaderPredicateBox, CommittedTransactionPredicateBox,
-        SignedBlockPredicateBox, SignedTransactionPredicateBox, TransactionErrorPredicateBox,
-        TransactionHashPredicateBox,
-    };
-}
-
-#[cfg(test)]
-mod test {
-    use iroha_crypto::{Hash, HashOf};
-
-    use crate::{
-        account::AccountId,
-        prelude::{
-            AccountIdPredicateBox, BlockHeaderPredicateBox, CompoundPredicate,
-            SignedBlockPredicateBox,
-        },
-        query::predicate::predicate_atoms::block::{
-            BlockHashPredicateBox, CommittedTransactionPredicateBox, SignedTransactionPredicateBox,
-            TransactionErrorPredicateBox, TransactionHashPredicateBox,
-        },
-    };
-
-    #[test]
-    fn transaction_smoke() {
-        let hash = Hash::prehashed([0; 32]);
-        let account_id: AccountId =
-            "ed0120CE7FA46C9DCE7EA4B125E2E36BDB63EA33073E7590AC92816AE1E861B7048B03@wonderland"
-                .parse()
-                .unwrap();
-
-        let predicate = CommittedTransactionPredicateBox::build(|tx| {
-            tx.block_hash.eq(HashOf::from_untyped_unchecked(hash))
-                & tx.value.authority.eq(account_id.clone())
-                & tx.value.hash.eq(HashOf::from_untyped_unchecked(hash))
-                & tx.error.is_some()
-        });
-
-        assert_eq!(
-            predicate,
-            CompoundPredicate::And(vec![
-                CompoundPredicate::Atom(CommittedTransactionPredicateBox::BlockHash(
-                    BlockHashPredicateBox::Equals(HashOf::from_untyped_unchecked(hash))
-                )),
-                CompoundPredicate::Atom(CommittedTransactionPredicateBox::Value(
-                    SignedTransactionPredicateBox::Authority(AccountIdPredicateBox::Equals(
-                        account_id.clone()
-                    ))
-                )),
-                CompoundPredicate::Atom(CommittedTransactionPredicateBox::Value(
-                    SignedTransactionPredicateBox::Hash(TransactionHashPredicateBox::Equals(
-                        HashOf::from_untyped_unchecked(hash)
-                    ))
-                )),
-                CompoundPredicate::Atom(CommittedTransactionPredicateBox::Error(
-                    TransactionErrorPredicateBox::IsSome
-                )),
-            ])
-        );
-    }
-
-    #[test]
-    fn block_smoke() {
-        let hash = Hash::prehashed([0; 32]);
-
-        let predicate = SignedBlockPredicateBox::build(|block| {
-            block.header.hash.eq(HashOf::from_untyped_unchecked(hash))
-        });
-
-        assert_eq!(
-            predicate,
-            CompoundPredicate::Atom(SignedBlockPredicateBox::Header(
-                BlockHeaderPredicateBox::Hash(BlockHashPredicateBox::Equals(
-                    HashOf::from_untyped_unchecked(hash)
-                ))
-            ))
-        );
-    }
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/domain.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/domain.rs
deleted file mode 100644
index 6c02c5bd56f..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/domain.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//! This module contains predicates for domain-related objects, mirroring [`crate::domain`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use iroha_version::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::{impl_predicate_box, MetadataPredicateBox};
-use crate::{
-    domain::{Domain, DomainId},
-    query::predicate::{
-        predicate_ast_extensions::AstPredicateExt as _,
-        predicate_atoms::StringPredicateBox,
-        predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-        projectors::BaseProjector,
-        AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to a [`Domain`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-#[allow(unreachable_patterns)]
-pub enum DomainPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the ID of the input.
-    Id(DomainIdPredicateBox),
-    /// Checks if a predicate applies to the metadata of the input.
-    Metadata(MetadataPredicateBox),
-}
-
-impl_predicate_box!(Domain: DomainPredicateBox);
-
-impl EvaluatePredicate<Domain> for DomainPredicateBox {
-    fn applies(&self, input: &Domain) -> bool {
-        match self {
-            DomainPredicateBox::Id(id) => id.applies(&input.id),
-            DomainPredicateBox::Metadata(metadata) => metadata.applies(&input.metadata),
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`DomainId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum DomainIdPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(DomainId),
-    // projections
-    /// Checks if a predicate applies to the name of the input.
-    Name(StringPredicateBox),
-}
-
-impl_predicate_box!(DomainId: DomainIdPredicateBox);
-
-impl EvaluatePredicate<DomainId> for DomainIdPredicateBox {
-    fn applies(&self, input: &DomainId) -> bool {
-        match self {
-            DomainIdPredicateBox::Equals(expected) => expected == input,
-            DomainIdPredicateBox::Name(name) => name.applies(&input.name),
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{DomainIdPredicateBox, DomainPredicateBox};
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/mod.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/mod.rs
deleted file mode 100644
index 4f1b3458491..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/mod.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-//! This module contains atomic predicates for all the different types supported by the predicate system.
-//!
-//! Generally, each of the atomic predicates is an enum that has two categories of variants:
-//! - Object-specific predicates, which check something that applies to the whole object, like [`account::AccountIdPredicateBox::Equals`] or [`StringPredicateBox::Contains`]
-//! - Projections, which check a predicate on some of the fields/inner values of the object, like [`account::AccountIdPredicateBox::DomainId`]
-
-#![allow(missing_copy_implementations)] // some predicates are not yet populated, but will be. They will stop being `Copy`able later, so don't bother with marking them as such now.
-
-pub mod account;
-pub mod asset;
-pub mod block;
-pub mod domain;
-pub mod parameter;
-pub mod peer;
-pub mod permission;
-pub mod role;
-pub mod trigger;
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_crypto::PublicKey;
-use iroha_schema::IntoSchema;
-use parity_scale_codec::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::{
-    predicate_ast_extensions::AstPredicateExt as _,
-    predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-    projectors::BaseProjector,
-    AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-};
-use crate::{metadata::Metadata, name::Name};
-
-/// Adds common methods to a predicate box.
-///
-/// Implements:
-/// 1. `build` and `build_fragment` methods for building a predicate using the dsl.
-/// 2. base-case `AstPredicate` for the predicate box (emits an atom expression).
-/// 3. `Not`, `BitAnd`, and `BitOr` operators for combining predicates.
-macro_rules! impl_predicate_box {
-    ($($ty:ty),+: $predicate_ty:ty) => {
-        impl $predicate_ty {
-            /// Build a new predicate in a normalized form. This predicate has limited composability and is generally useful only to be passed to queries.
-            pub fn build<F, O>(predicate: F) -> CompoundPredicate<Self>
-            where
-                F: FnOnce(<Self as HasPrototype>::Prototype<BaseProjector<Self>>) -> O,
-                O: AstPredicate<Self>,
-            {
-                predicate(Default::default()).normalize()
-            }
-
-            /// Build a new predicate without normalizing it. The resulting predicate can be freely composed with other predicates using logical operators, or by calling `.satisfies` method on a prototype.
-            pub fn build_fragment<F, O>(predicate: F) -> O
-            where
-                F: FnOnce(<Self as HasPrototype>::Prototype<BaseProjector<Self>>) -> O,
-                O: AstPredicate<Self>,
-            {
-                predicate(Default::default())
-            }
-        }
-
-        $(
-            impl HasPredicateBox for $ty {
-                type PredicateBoxType = $predicate_ty;
-            }
-        )+
-
-        impl AstPredicate<$predicate_ty> for $predicate_ty {
-            fn normalize_with_proj<OutputType, Proj>(self, proj: Proj) -> CompoundPredicate<OutputType>
-            where
-                Proj: Fn($predicate_ty) -> OutputType + Copy,
-            {
-                CompoundPredicate::Atom(proj(self))
-            }
-        }
-
-        impl core::ops::Not for $predicate_ty
-        where
-            Self: AstPredicate<$predicate_ty>,
-        {
-            type Output = NotAstPredicate<Self>;
-
-            fn not(self) -> Self::Output {
-                NotAstPredicate(self)
-            }
-        }
-
-        impl<PRhs> core::ops::BitAnd<PRhs> for $predicate_ty
-        where
-            Self: AstPredicate<$predicate_ty>,
-            PRhs: AstPredicate<$predicate_ty>,
-        {
-            type Output = AndAstPredicate<Self, PRhs>;
-
-            fn bitand(self, rhs: PRhs) -> Self::Output {
-                AndAstPredicate(self, rhs)
-            }
-        }
-
-        impl<PRhs> core::ops::BitOr<PRhs> for $predicate_ty
-        where
-            Self: AstPredicate<$predicate_ty>,
-            PRhs: AstPredicate<$predicate_ty>,
-        {
-            type Output = OrAstPredicate<Self, PRhs>;
-
-            fn bitor(self, rhs: PRhs) -> Self::Output {
-                OrAstPredicate(self, rhs)
-            }
-        }
-    };
-}
-pub(crate) use impl_predicate_box;
-
-/// A predicate that can be applied to a [`String`]-like types.
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum StringPredicateBox {
-    /// Checks if the input is equal to the expected value
-    Equals(String),
-    /// Checks if the input contains an expected substring, like [`str::contains()`]
-    Contains(String),
-    /// Checks if the input starts with an expected substring, like [`str::starts_with()`]
-    StartsWith(String),
-    /// Checks if the input ends with an expected substring, like [`str::ends_with()`]
-    EndsWith(String),
-}
-
-impl_predicate_box!(String, Name: StringPredicateBox);
-
-impl<T> EvaluatePredicate<T> for StringPredicateBox
-where
-    T: AsRef<str>,
-{
-    fn applies(&self, input: &T) -> bool {
-        let input = input.as_ref();
-        match self {
-            StringPredicateBox::Contains(content) => input.contains(content),
-            StringPredicateBox::StartsWith(content) => input.starts_with(content),
-            StringPredicateBox::EndsWith(content) => input.ends_with(content),
-            StringPredicateBox::Equals(content) => *input == *content,
-        }
-    }
-}
-
-/// A predicate that can be applied to [`Metadata`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum MetadataPredicateBox {
-    // TODO: populate
-    // FIX: Remove all `#[allow(unreachable_patterns)]` from all use sites
-    // once some variants are added into this enum
-}
-
-impl_predicate_box!(Metadata: MetadataPredicateBox);
-
-impl EvaluatePredicate<Metadata> for MetadataPredicateBox {
-    fn applies(&self, _input: &Metadata) -> bool {
-        match *self {}
-    }
-}
-
-/// A predicate that can be applied to a [`PublicKey`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum PublicKeyPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(PublicKey),
-}
-
-impl_predicate_box!(PublicKey: PublicKeyPredicateBox);
-
-impl EvaluatePredicate<PublicKey> for PublicKeyPredicateBox {
-    fn applies(&self, input: &PublicKey) -> bool {
-        match self {
-            PublicKeyPredicateBox::Equals(expected) => expected == input,
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{
-        account::prelude::*, asset::prelude::*, block::prelude::*, domain::prelude::*,
-        parameter::prelude::*, peer::prelude::*, permission::prelude::*, role::prelude::*,
-        trigger::prelude::*, MetadataPredicateBox, PublicKeyPredicateBox, StringPredicateBox,
-    };
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/parameter.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/parameter.rs
deleted file mode 100644
index fe1a74a10e5..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/parameter.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! This module contains predicates for parameter-related objects, mirroring [`crate::parameter`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use parity_scale_codec::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    parameter::Parameter,
-    query::predicate::{
-        predicate_ast_extensions::AstPredicateExt as _,
-        predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-        projectors::BaseProjector,
-        AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to a [`Parameter`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum ParameterPredicateBox {
-    // nothing here yet
-}
-
-impl_predicate_box!(Parameter: ParameterPredicateBox);
-
-impl EvaluatePredicate<Parameter> for ParameterPredicateBox {
-    fn applies(&self, _input: &Parameter) -> bool {
-        match *self {}
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::ParameterPredicateBox;
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/peer.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/peer.rs
deleted file mode 100644
index a3512c8ee4d..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/peer.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! This module contains predicates for peer-related objects, mirroring [`crate::peer`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use parity_scale_codec::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    peer::PeerId,
-    query::predicate::{
-        predicate_ast_extensions::AstPredicateExt as _,
-        predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-        projectors::BaseProjector,
-        AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to a [`Peer`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum PeerPredicateBox {
-    // nothing here yet
-}
-
-impl_predicate_box!(PeerId: PeerPredicateBox);
-
-impl EvaluatePredicate<PeerId> for PeerPredicateBox {
-    fn applies(&self, _input: &PeerId) -> bool {
-        match *self {}
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::PeerPredicateBox;
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/permission.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/permission.rs
deleted file mode 100644
index 5d0bc4494bc..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/permission.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! This module contains predicates for permission-related objects, mirroring [`crate::permission`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use parity_scale_codec::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    permission::Permission,
-    query::predicate::{
-        predicate_ast_extensions::AstPredicateExt as _,
-        predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-        projectors::BaseProjector,
-        AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to a [`Permission`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum PermissionPredicateBox {
-    // nothing here yet
-}
-
-impl_predicate_box!(Permission: PermissionPredicateBox);
-
-impl EvaluatePredicate<Permission> for PermissionPredicateBox {
-    fn applies(&self, _input: &Permission) -> bool {
-        match *self {}
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::PermissionPredicateBox;
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/role.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/role.rs
deleted file mode 100644
index 7c2636bee01..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/role.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! This module contains predicates for role-related objects, mirroring [`crate::role`].
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use iroha_version::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    prelude::{Role, RoleId},
-    query::{
-        predicate::{
-            predicate_ast_extensions::AstPredicateExt as _,
-            predicate_atoms::StringPredicateBox,
-            predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-            projectors::BaseProjector,
-        },
-        AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to a [`RoleId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum RoleIdPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(RoleId),
-    // projections
-    /// Checks if a predicate applies to the name of the input.
-    Name(StringPredicateBox),
-}
-
-impl_predicate_box!(RoleId: RoleIdPredicateBox);
-
-impl EvaluatePredicate<RoleId> for RoleIdPredicateBox {
-    fn applies(&self, input: &RoleId) -> bool {
-        match self {
-            RoleIdPredicateBox::Equals(expected) => expected == input,
-            RoleIdPredicateBox::Name(name) => name.applies(&input.name),
-        }
-    }
-}
-
-/// A predicate that can be applied to a [`Role`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum RolePredicateBox {
-    // projections
-    /// Checks if a predicate applies to the ID of the input.
-    Id(RoleIdPredicateBox),
-}
-
-impl_predicate_box!(Role: RolePredicateBox);
-
-impl EvaluatePredicate<Role> for RolePredicateBox {
-    fn applies(&self, input: &Role) -> bool {
-        match self {
-            RolePredicateBox::Id(id) => id.applies(&input.id),
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{RoleIdPredicateBox, RolePredicateBox};
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_atoms/trigger.rs b/crates/iroha_data_model/src/query/predicate/predicate_atoms/trigger.rs
deleted file mode 100644
index 3998ebf78f7..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_atoms/trigger.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-//! This module contains predicates for trigger-related objects, mirroring [`crate::trigger`]
-
-#[cfg(not(feature = "std"))]
-use alloc::{format, string::String, vec::Vec};
-
-use iroha_schema::IntoSchema;
-use iroha_version::{Decode, Encode};
-use serde::{Deserialize, Serialize};
-
-use super::impl_predicate_box;
-use crate::{
-    prelude::{Trigger, TriggerId},
-    query::predicate::{
-        predicate_ast_extensions::AstPredicateExt as _,
-        predicate_atoms::StringPredicateBox,
-        predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-        projectors::BaseProjector,
-        AstPredicate, CompoundPredicate, EvaluatePredicate, HasPredicateBox, HasPrototype,
-    },
-};
-
-/// A predicate that can be applied to a [`TriggerId`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum TriggerIdPredicateBox {
-    // object-specific predicates
-    /// Checks if the input is equal to the expected value.
-    Equals(TriggerId),
-    // projections
-    /// Checks if a predicate applies to the name of the input.
-    Name(StringPredicateBox),
-}
-
-impl EvaluatePredicate<TriggerId> for TriggerIdPredicateBox {
-    fn applies(&self, input: &TriggerId) -> bool {
-        match self {
-            TriggerIdPredicateBox::Equals(expected) => expected == input,
-            TriggerIdPredicateBox::Name(name) => name.applies(&input.name),
-        }
-    }
-}
-
-impl_predicate_box!(TriggerId: TriggerIdPredicateBox);
-
-/// A predicate that can be applied to a [`Trigger`].
-#[derive(Debug, Clone, PartialEq, Eq, Decode, Encode, Deserialize, Serialize, IntoSchema)]
-pub enum TriggerPredicateBox {
-    // projections
-    /// Checks if a predicate applies to the ID of the input.
-    Id(TriggerIdPredicateBox),
-}
-
-impl_predicate_box!(Trigger: TriggerPredicateBox);
-
-impl EvaluatePredicate<Trigger> for TriggerPredicateBox {
-    fn applies(&self, input: &Trigger) -> bool {
-        match self {
-            TriggerPredicateBox::Id(id) => id.applies(&input.id),
-        }
-    }
-}
-
-pub mod prelude {
-    //! Re-export all predicate boxes for a glob import `(::*)`
-    pub use super::{TriggerIdPredicateBox, TriggerPredicateBox};
-}
diff --git a/crates/iroha_data_model/src/query/predicate/predicate_combinators.rs b/crates/iroha_data_model/src/query/predicate/predicate_combinators.rs
deleted file mode 100644
index 44012705e46..00000000000
--- a/crates/iroha_data_model/src/query/predicate/predicate_combinators.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//! Module containing AST predicate combinators, implementing logical operations.
-
-use super::{AstPredicate, CompoundPredicate};
-
-/// Overrides the `Not`, `BitAnd`, and `BitOr` operators for easier predicate composition.
-macro_rules! impl_ops {
-    ($name:ident<$($generic_name:ident),*>) => {
-        impl<$($generic_name),*> core::ops::Not for $name<$($generic_name),*>
-        // it would be nice to have a `Self: AstPredicate<PredType>` bound here, but it is not possible due to `E0207`: unconstrained type parameter
-        {
-            type Output = NotAstPredicate<Self>;
-
-            fn not(self) -> Self::Output {
-                NotAstPredicate(self)
-            }
-        }
-
-        impl<PRhs, $($generic_name),*> core::ops::BitAnd<PRhs> for $name<$($generic_name),*>
-        {
-            type Output = AndAstPredicate<Self, PRhs>;
-
-            fn bitand(self, rhs: PRhs) -> Self::Output {
-                AndAstPredicate(self, rhs)
-            }
-        }
-
-        impl<PRhs, $($generic_name),*> core::ops::BitOr<PRhs> for $name<$($generic_name),*>
-        {
-            type Output = OrAstPredicate<Self, PRhs>;
-
-            fn bitor(self, rhs: PRhs) -> Self::Output {
-                OrAstPredicate(self, rhs)
-            }
-        }
-    };
-}
-
-/// Invert the AST predicate - apply not operation.
-pub struct NotAstPredicate<P>(pub P);
-
-impl_ops!(NotAstPredicate<P>);
-
-impl<PredType, P> AstPredicate<PredType> for NotAstPredicate<P>
-where
-    P: AstPredicate<PredType>,
-{
-    fn normalize_with_proj<OutputType, Proj>(self, proj: Proj) -> CompoundPredicate<OutputType>
-    where
-        Proj: Fn(PredType) -> OutputType + Copy,
-    {
-        let NotAstPredicate(inner) = self;
-
-        // project the inner predicate and negate it
-        // use `CompoundPredicate` combinator methods that have flattening optimization
-        inner.normalize_with_proj(proj).not()
-    }
-}
-
-/// Combine two AST predicates with logical OR.
-pub struct OrAstPredicate<P1, P2>(pub P1, pub P2);
-
-impl<PredType, P1, P2> AstPredicate<PredType> for OrAstPredicate<P1, P2>
-where
-    P1: AstPredicate<PredType>,
-    P2: AstPredicate<PredType>,
-{
-    fn normalize_with_proj<OutputType, Proj>(self, proj: Proj) -> CompoundPredicate<OutputType>
-    where
-        Proj: Fn(PredType) -> OutputType + Copy,
-    {
-        let OrAstPredicate(lhs, rhs) = self;
-
-        // project the inner predicates and combine them with an or
-        // use `CompoundPredicate` combinator methods that have flattening optimization
-        lhs.normalize_with_proj(proj)
-            .or(rhs.normalize_with_proj(proj))
-    }
-}
-
-impl_ops!(OrAstPredicate<P1, P2>);
-
-/// Combine two AST predicates with logical AND.
-pub struct AndAstPredicate<P1, P2>(pub P1, pub P2);
-
-impl<PredType, P1, P2> AstPredicate<PredType> for AndAstPredicate<P1, P2>
-where
-    P1: AstPredicate<PredType>,
-    P2: AstPredicate<PredType>,
-{
-    fn normalize_with_proj<OutputType, Proj>(self, proj: Proj) -> CompoundPredicate<OutputType>
-    where
-        Proj: Fn(PredType) -> OutputType + Copy,
-    {
-        let AndAstPredicate(lhs, rhs) = self;
-
-        // project the inner predicates and combine them with an and
-        // use `CompoundPredicate` combinator methods that have flattening optimization
-        lhs.normalize_with_proj(proj)
-            .and(rhs.normalize_with_proj(proj))
-    }
-}
-
-impl_ops!(AndAstPredicate<P1, P2>);
diff --git a/crates/iroha_data_model/src/query/predicate/projectors.rs b/crates/iroha_data_model/src/query/predicate/projectors.rs
deleted file mode 100644
index 45ea67cba26..00000000000
--- a/crates/iroha_data_model/src/query/predicate/projectors.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-//! Defines projectors and projections for predicates DSL.
-//!
-//! Projection is an AST predicate combinator that changes the type of the inner predicate by wrapping it in a projection variant on normalization.
-//!
-//! Projector is a helper struct implementing the [`ObjectProjector`] trait that applies the projection.
-
-use core::marker::PhantomData;
-
-use super::{AstPredicate, CompoundPredicate};
-use crate::{
-    prelude::{BlockHeaderPredicateBox, SignedBlockPredicateBox},
-    query::predicate::{
-        predicate_atoms::{
-            account::{AccountIdPredicateBox, AccountPredicateBox},
-            asset::{
-                AssetDefinitionIdPredicateBox, AssetDefinitionPredicateBox, AssetIdPredicateBox,
-                AssetPredicateBox, AssetValuePredicateBox,
-            },
-            block::{
-                BlockHashPredicateBox, CommittedTransactionPredicateBox,
-                SignedTransactionPredicateBox, TransactionErrorPredicateBox,
-                TransactionHashPredicateBox,
-            },
-            domain::{DomainIdPredicateBox, DomainPredicateBox},
-            role::{RoleIdPredicateBox, RolePredicateBox},
-            trigger::{TriggerIdPredicateBox, TriggerPredicateBox},
-            MetadataPredicateBox, PublicKeyPredicateBox, StringPredicateBox,
-        },
-        predicate_combinators::{AndAstPredicate, NotAstPredicate, OrAstPredicate},
-    },
-};
-
-/// Describes how to convert `AstPredicate<Input>` to `AstPredicate<Output>` by wrapping them in some projection predicate combinator.
-pub trait ObjectProjector: Default + Copy + Clone {
-    /// The type of the input atomic predicate (the more concrete type).
-    type Input;
-    /// The type of the output atomic predicate (the more general type).
-    type Output;
-
-    /// The type of result of projecting `P` AST predicate.
-    type ProjectedPredicate<P: AstPredicate<Self::Input>>: AstPredicate<Self::Output>;
-
-    /// Project the given predicate.
-    fn project_predicate<P: AstPredicate<Self::Input>>(predicate: P)
-        -> Self::ProjectedPredicate<P>;
-}
-
-/// An [`ObjectProjector`] that does not change the type, serving as a base case for the recursion.
-pub struct BaseProjector<T>(PhantomData<T>);
-
-// manual implementation of traits to not add bounds on `T`
-impl<T> Default for BaseProjector<T> {
-    fn default() -> Self {
-        Self(PhantomData)
-    }
-}
-
-impl<T> Copy for BaseProjector<T> {}
-
-impl<T> Clone for BaseProjector<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T> ObjectProjector for BaseProjector<T> {
-    type Input = T;
-    type Output = T;
-    type ProjectedPredicate<P: AstPredicate<T>> = P;
-
-    fn project_predicate<P: AstPredicate<T>>(predicate: P) -> Self::ProjectedPredicate<P> {
-        predicate
-    }
-}
-
-/// A helper macro to define a projector and a projection
-macro_rules! proj {
-    ($projector:ident($projection:ident): $in_predicate:ident => $out_predicate:ident::$proj_variant:ident) => {
-        #[doc = "An AST predicate that projects [`"]
-        #[doc = stringify!($in_predicate)]
-        #[doc = "`] to [`"]
-        #[doc = stringify!($out_predicate)]
-        #[doc = "`] by wrapping it in [`"]
-        #[doc = concat!(stringify!($out_predicate), "::", stringify!($proj_variant))]
-        #[doc = "`]."]
-        #[derive(Default, Copy, Clone)]
-        pub struct $projection<P>(P);
-
-        impl<P> AstPredicate<$out_predicate> for $projection<P>
-        where
-            P: AstPredicate<$in_predicate>,
-        {
-            fn normalize_with_proj<OutputType, Proj>(
-                self,
-                proj: Proj,
-            ) -> CompoundPredicate<OutputType>
-            where
-                Proj: Fn($out_predicate) -> OutputType + Copy,
-            {
-                self.0
-                    .normalize_with_proj(|p| proj($out_predicate::$proj_variant(p)))
-            }
-        }
-
-        impl<P> core::ops::Not for $projection<P>
-        where
-            Self: AstPredicate<$out_predicate>,
-        {
-            type Output = NotAstPredicate<Self>;
-
-            fn not(self) -> Self::Output {
-                NotAstPredicate(self)
-            }
-        }
-
-        impl<P, PRhs> core::ops::BitAnd<PRhs> for $projection<P>
-        where
-            Self: AstPredicate<$out_predicate>,
-            PRhs: AstPredicate<$out_predicate>,
-        {
-            type Output = AndAstPredicate<Self, PRhs>;
-
-            fn bitand(self, rhs: PRhs) -> Self::Output {
-                AndAstPredicate(self, rhs)
-            }
-        }
-
-        impl<P, PRhs> core::ops::BitOr<PRhs> for $projection<P>
-        where
-            Self: AstPredicate<$out_predicate>,
-            PRhs: AstPredicate<$out_predicate>,
-        {
-            type Output = OrAstPredicate<Self, PRhs>;
-
-            fn bitor(self, rhs: PRhs) -> Self::Output {
-                OrAstPredicate(self, rhs)
-            }
-        }
-
-        #[doc = "An [`ObjectProjector`] that applies [`"]
-        #[doc = stringify!($projection)]
-        #[doc = "`]."]
-        #[derive(Default, Copy, Clone)]
-        pub struct $projector<Base>(PhantomData<Base>);
-
-        impl<Base: ObjectProjector<Input = $out_predicate>> ObjectProjector for $projector<Base> {
-            type Input = $in_predicate;
-            type Output = Base::Output;
-            type ProjectedPredicate<P: AstPredicate<Self::Input>> =
-                Base::ProjectedPredicate<$projection<P>>;
-
-            fn project_predicate<P: AstPredicate<Self::Input>>(
-                predicate: P,
-            ) -> Self::ProjectedPredicate<P> {
-                Base::project_predicate($projection(predicate))
-            }
-        }
-    };
-}
-
-// projections on AccountId
-proj!(AccountIdDomainIdProjector(AccountIdDomainIdProjection): DomainIdPredicateBox => AccountIdPredicateBox::DomainId);
-proj!(AccountIdSignatoryProjector(AccountIdSignatoryProjection): PublicKeyPredicateBox => AccountIdPredicateBox::Signatory);
-
-// projections on Account
-proj!(AccountIdProjector(AccountIdProjection): AccountIdPredicateBox => AccountPredicateBox::Id);
-proj!(AccountMetadataProjector(AccountMetadataProjection): MetadataPredicateBox => AccountPredicateBox::Metadata);
-
-// projections on AssetDefinitionId
-proj!(AssetDefinitionIdDomainIdProjector(AssetDefinitionIdDomainIdProjection): DomainIdPredicateBox => AssetDefinitionIdPredicateBox::DomainId);
-proj!(AssetDefinitionIdNameProjector(AssetDefinitionIdNameProjection): StringPredicateBox => AssetDefinitionIdPredicateBox::Name);
-
-// projections on AssetId
-proj!(AssetIdDefinitionIdProjector(AssetIdDefinitionIdProjection): AssetDefinitionIdPredicateBox => AssetIdPredicateBox::DefinitionId);
-proj!(AssetIdAccountIdProjector(AssetIdAccountIdProjection): AccountIdPredicateBox => AssetIdPredicateBox::AccountId);
-
-// projections on AssetDefinition
-proj!(AssetDefinitionIdProjector(AssetDefinitionIdProjection): AssetDefinitionIdPredicateBox => AssetDefinitionPredicateBox::Id);
-proj!(AssetDefinitionMetadataProjector(AssetDefinitionMetadataProjection): MetadataPredicateBox => AssetDefinitionPredicateBox::Metadata);
-
-// projections on Asset
-proj!(AssetIdProjector(AssetIdProjection): AssetIdPredicateBox => AssetPredicateBox::Id);
-proj!(AssetValueProjector(AssetValueProjection): AssetValuePredicateBox => AssetPredicateBox::Value);
-
-// projections on DomainId
-proj!(DomainIdNameProjector(DomainIdNameProjection): StringPredicateBox => DomainIdPredicateBox::Name);
-
-// projections on Domain
-proj!(DomainIdProjector(DomainIdProjection): DomainIdPredicateBox => DomainPredicateBox::Id);
-proj!(DomainMetadataProjector(DomainMetadataProjection): MetadataPredicateBox => DomainPredicateBox::Metadata);
-
-// projections on RoleId
-proj!(RoleIdNameProjector(RoleIdNameProjection): StringPredicateBox => RoleIdPredicateBox::Name);
-
-// projections on Role
-proj!(RoleIdProjector(RoleIdProjection): RoleIdPredicateBox => RolePredicateBox::Id);
-
-// projections on TriggerId
-proj!(TriggerIdNameProjector(TriggerIdNameProjection): StringPredicateBox => TriggerIdPredicateBox::Name);
-
-// projections on Trigger
-proj!(TriggerIdProjector(TriggerIdProjection): TriggerIdPredicateBox => TriggerPredicateBox::Id);
-
-// projections on BlockHeader
-proj!(BlockHeaderHashProjector(BlockHeaderHashProjection): BlockHashPredicateBox => BlockHeaderPredicateBox::Hash);
-
-// projections on SignedBlock
-proj!(SignedBlockHeaderProjector(SignedBlockHeaderProjection): BlockHeaderPredicateBox => SignedBlockPredicateBox::Header);
-
-// projections on SignedTransaction
-proj!(SignedTransactionHashProjector(SignedTransactionHashProjection): TransactionHashPredicateBox => SignedTransactionPredicateBox::Hash);
-proj!(SignedTransactionAuthorityProjector(SignedTransactionAuthorityProjection): AccountIdPredicateBox => SignedTransactionPredicateBox::Authority);
-
-// projections on CommittedTransaction
-proj!(CommittedTransactionBlockHashProjector(CommittedTransactionBlockHashProjection): BlockHashPredicateBox => CommittedTransactionPredicateBox::BlockHash);
-proj!(CommittedTransactionValueProjector(CommittedTransactionValueProjection): SignedTransactionPredicateBox => CommittedTransactionPredicateBox::Value);
-proj!(CommittedTransactionErrorProjector(CommittedTransactionErrorProjection): TransactionErrorPredicateBox => CommittedTransactionPredicateBox::Error);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/account.rs b/crates/iroha_data_model/src/query/predicate/prototypes/account.rs
deleted file mode 100644
index 003819598af..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/account.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::account`].
-
-use super::impl_prototype;
-use crate::{
-    account::AccountId,
-    query::{
-        predicate::{
-            predicate_atoms::account::{AccountIdPredicateBox, AccountPredicateBox},
-            projectors::{
-                AccountIdDomainIdProjector, AccountIdProjector, AccountIdSignatoryProjector,
-                AccountMetadataProjector, ObjectProjector,
-            },
-            prototypes::{domain::DomainIdPrototype, MetadataPrototype, PublicKeyPrototype},
-        },
-        AstPredicate, HasPrototype,
-    },
-};
-
-/// A prototype of [`AccountId`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AccountIdPrototype<Projector> {
-    /// Build a predicate on domain ID of this [`AccountId`]
-    pub domain_id: DomainIdPrototype<AccountIdDomainIdProjector<Projector>>,
-    /// Build a predicate on signatory of this [`AccountId`]
-    pub signatory: PublicKeyPrototype<AccountIdSignatoryProjector<Projector>>,
-}
-
-impl_prototype!(AccountIdPrototype: AccountIdPredicateBox);
-
-impl<Projector> AccountIdPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = AccountIdPredicateBox>,
-{
-    /// Creates a predicate that checks if the account ID equals the expected value.
-    pub fn eq(&self, expected: AccountId) -> Projector::ProjectedPredicate<AccountIdPredicateBox> {
-        Projector::project_predicate(AccountIdPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`crate::account::Account`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AccountPrototype<Projector> {
-    /// Build a predicate on ID of this [`crate::account::Account`]
-    pub id: AccountIdPrototype<AccountIdProjector<Projector>>,
-    /// Build a predicate on metadata of this [`crate::account::Account`]
-    pub metadata: MetadataPrototype<AccountMetadataProjector<Projector>>,
-}
-
-impl_prototype!(AccountPrototype: AccountPredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/asset.rs b/crates/iroha_data_model/src/query/predicate/prototypes/asset.rs
deleted file mode 100644
index aa48f671363..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/asset.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::asset`].
-
-use core::marker::PhantomData;
-
-use super::{impl_prototype, MetadataPrototype, StringPrototype};
-use crate::{
-    asset::{AssetDefinitionId, AssetId},
-    query::{
-        predicate::{
-            predicate_atoms::asset::{
-                AssetDefinitionIdPredicateBox, AssetDefinitionPredicateBox, AssetIdPredicateBox,
-                AssetPredicateBox, AssetValuePredicateBox,
-            },
-            projectors::{
-                AssetDefinitionIdDomainIdProjector, AssetDefinitionIdNameProjector,
-                AssetDefinitionIdProjector, AssetDefinitionMetadataProjector,
-                AssetIdAccountIdProjector, AssetIdDefinitionIdProjector, AssetIdProjector,
-                AssetValueProjector,
-            },
-            prototypes::{account::AccountIdPrototype, domain::DomainIdPrototype, ObjectProjector},
-        },
-        AstPredicate, HasPrototype,
-    },
-};
-
-/// A prototype of [`AssetDefinitionId`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AssetDefinitionIdPrototype<Projector> {
-    /// Build a predicate on domain ID of this [`AssetDefinitionId`]
-    pub domain_id: DomainIdPrototype<AssetDefinitionIdDomainIdProjector<Projector>>,
-    /// Build a predicate on name of this [`AssetDefinitionId`]
-    pub name: StringPrototype<AssetDefinitionIdNameProjector<Projector>>,
-}
-
-impl_prototype!(AssetDefinitionIdPrototype: AssetDefinitionIdPredicateBox);
-
-impl<Projector> AssetDefinitionIdPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = AssetDefinitionIdPredicateBox>,
-{
-    /// Creates a predicate that checks if the asset definition ID equals the expected value.
-    pub fn eq(
-        &self,
-        expected: AssetDefinitionId,
-    ) -> Projector::ProjectedPredicate<AssetDefinitionIdPredicateBox> {
-        Projector::project_predicate(AssetDefinitionIdPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`AssetId`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AssetIdPrototype<Projector> {
-    /// Build a predicate on definition ID of this [`AssetId`]
-    pub definition_id: AssetDefinitionIdPrototype<AssetIdDefinitionIdProjector<Projector>>,
-    /// Build a predicate on account ID of this [`AssetId`]
-    pub account: AccountIdPrototype<AssetIdAccountIdProjector<Projector>>,
-}
-
-impl_prototype!(AssetIdPrototype: AssetIdPredicateBox);
-
-impl<Projector> AssetIdPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = AssetIdPredicateBox>,
-{
-    /// Creates a predicate that checks if the asset ID equals the expected value.
-    pub fn eq(&self, expected: AssetId) -> Projector::ProjectedPredicate<AssetIdPredicateBox> {
-        Projector::project_predicate(AssetIdPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`crate::asset::AssetDefinition`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AssetDefinitionPrototype<Projector> {
-    /// Build a predicate on ID of this [`crate::asset::AssetDefinition`]
-    pub id: AssetDefinitionIdPrototype<AssetDefinitionIdProjector<Projector>>,
-    /// Build a predicate on metadata of this [`crate::asset::AssetDefinition`]
-    pub metadata: MetadataPrototype<AssetDefinitionMetadataProjector<Projector>>,
-}
-
-impl_prototype!(AssetDefinitionPrototype: AssetDefinitionPredicateBox);
-
-/// A prototype of [`crate::asset::Asset`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AssetPrototype<Projector> {
-    /// Build a predicate on ID of this [`crate::asset::Asset`]
-    pub id: AssetIdPrototype<AssetIdProjector<Projector>>,
-    /// Build a predicate on value of this [`crate::asset::Asset`]
-    pub value: AssetValuePrototype<AssetValueProjector<Projector>>,
-}
-
-impl_prototype!(AssetPrototype: AssetPredicateBox);
-
-/// A prototype of [`crate::asset::AssetValue`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct AssetValuePrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(AssetValuePrototype: AssetValuePredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/block.rs b/crates/iroha_data_model/src/query/predicate/prototypes/block.rs
deleted file mode 100644
index f72e59a0211..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/block.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::block`].
-
-use core::marker::PhantomData;
-
-use iroha_crypto::HashOf;
-
-use super::impl_prototype;
-use crate::{
-    block::BlockHeader,
-    query::predicate::{
-        predicate_ast_extensions::AstPredicateExt,
-        predicate_atoms::block::{
-            BlockHashPredicateBox, BlockHeaderPredicateBox, CommittedTransactionPredicateBox,
-            SignedBlockPredicateBox, SignedTransactionPredicateBox, TransactionErrorPredicateBox,
-            TransactionHashPredicateBox,
-        },
-        predicate_combinators::NotAstPredicate,
-        projectors::{
-            BlockHeaderHashProjector, CommittedTransactionBlockHashProjector,
-            CommittedTransactionErrorProjector, CommittedTransactionValueProjector,
-            ObjectProjector, SignedBlockHeaderProjector, SignedTransactionAuthorityProjector,
-            SignedTransactionHashProjector,
-        },
-        prototypes::account::AccountIdPrototype,
-        AstPredicate, HasPrototype,
-    },
-    transaction::SignedTransaction,
-};
-
-/// A prototype of [`HashOf<BlockHeader>`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct BlockHashPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(BlockHashPrototype: BlockHashPredicateBox);
-
-impl<Projector> BlockHashPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = BlockHashPredicateBox>,
-{
-    /// Creates a predicate that checks if the hash equals the expected value.
-    pub fn eq(
-        &self,
-        expected: HashOf<BlockHeader>,
-    ) -> Projector::ProjectedPredicate<BlockHashPredicateBox> {
-        Projector::project_predicate(BlockHashPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`BlockHeader`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct BlockHeaderPrototype<Projector> {
-    /// Build a predicate on hash of this [`BlockHeader`]
-    pub hash: BlockHashPrototype<BlockHeaderHashProjector<Projector>>,
-}
-
-impl_prototype!(BlockHeaderPrototype: BlockHeaderPredicateBox);
-
-/// A prototype of [`crate::block::SignedBlock`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct SignedBlockPrototype<Projector> {
-    /// Build a predicate on header of this [`crate::block::SignedBlock`]
-    pub header: BlockHeaderPrototype<SignedBlockHeaderProjector<Projector>>,
-}
-
-impl_prototype!(SignedBlockPrototype: SignedBlockPredicateBox);
-
-/// A prototype of [`HashOf<SignedTransaction>`]
-#[derive(Default, Copy, Clone)]
-pub struct TransactionHashPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(TransactionHashPrototype: TransactionHashPredicateBox);
-
-impl<Projector> TransactionHashPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = TransactionHashPredicateBox>,
-{
-    /// Creates a predicate that checks if the hash equals the expected value.
-    pub fn eq(
-        &self,
-        expected: HashOf<SignedTransaction>,
-    ) -> Projector::ProjectedPredicate<TransactionHashPredicateBox> {
-        Projector::project_predicate(TransactionHashPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`SignedTransaction`]
-#[derive(Default, Copy, Clone)]
-pub struct SignedTransactionPrototype<Projector> {
-    /// Build a predicate on hash of this [`SignedTransaction`]
-    pub hash: TransactionHashPrototype<SignedTransactionHashProjector<Projector>>,
-    /// Build a predicate on the transaction authority
-    pub authority: AccountIdPrototype<SignedTransactionAuthorityProjector<Projector>>,
-}
-
-impl_prototype!(SignedTransactionPrototype: SignedTransactionPredicateBox);
-
-/// A prototype of [`Option<crate::transaction::error::TransactionRejectionReason>`]
-#[derive(Default, Copy, Clone)]
-pub struct TransactionErrorPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(TransactionErrorPrototype: TransactionErrorPredicateBox);
-
-impl<Projector> TransactionErrorPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = TransactionErrorPredicateBox>,
-{
-    /// Creates a predicate that checks if there is an error.
-    pub fn is_some(&self) -> Projector::ProjectedPredicate<TransactionErrorPredicateBox> {
-        Projector::project_predicate(TransactionErrorPredicateBox::IsSome)
-    }
-
-    /// Creates a predicate that checks if there is no error.
-    pub fn is_none(
-        &self,
-    ) -> NotAstPredicate<Projector::ProjectedPredicate<TransactionErrorPredicateBox>> {
-        Projector::project_predicate(TransactionErrorPredicateBox::IsSome).not()
-    }
-}
-
-/// A prototype of [`crate::query::CommittedTransaction`] for predicate construction.
-#[derive(Default, Clone)]
-pub struct CommittedTransactionPrototype<Projector> {
-    /// Build a predicate on the block hash inside
-    pub block_hash: BlockHashPrototype<CommittedTransactionBlockHashProjector<Projector>>,
-    /// Build a predicate on the transaction inside
-    pub value: SignedTransactionPrototype<CommittedTransactionValueProjector<Projector>>,
-    /// Build a predicate on the transaction error
-    pub error: TransactionErrorPrototype<CommittedTransactionErrorProjector<Projector>>,
-}
-
-impl_prototype!(CommittedTransactionPrototype: CommittedTransactionPredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/domain.rs b/crates/iroha_data_model/src/query/predicate/prototypes/domain.rs
deleted file mode 100644
index 4f8966bac55..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/domain.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::domain`].
-
-use super::{impl_prototype, MetadataPrototype, StringPrototype};
-use crate::{
-    domain::DomainId,
-    query::predicate::{
-        predicate_atoms::domain::{DomainIdPredicateBox, DomainPredicateBox},
-        projectors::{
-            DomainIdNameProjector, DomainIdProjector, DomainMetadataProjector, ObjectProjector,
-        },
-        AstPredicate, HasPrototype,
-    },
-};
-
-/// A prototype of [`DomainId`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct DomainIdPrototype<Projector> {
-    /// Build a predicate on name of this [`DomainId`]
-    pub name: StringPrototype<DomainIdNameProjector<Projector>>,
-}
-
-impl_prototype!(DomainIdPrototype: DomainIdPredicateBox);
-
-impl<Projector> DomainIdPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = DomainIdPredicateBox>,
-{
-    /// Creates a predicate that checks if the domain ID is equal to the expected value.
-    pub fn eq(&self, expected: DomainId) -> Projector::ProjectedPredicate<DomainIdPredicateBox> {
-        Projector::project_predicate(DomainIdPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`crate::domain::Domain`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct DomainPrototype<Projector> {
-    /// Build a predicate on ID of this [`crate::domain::Domain`]
-    pub id: DomainIdPrototype<DomainIdProjector<Projector>>,
-    /// Build a predicate on metadata of this [`crate::domain::Domain`]
-    pub metadata: MetadataPrototype<DomainMetadataProjector<Projector>>,
-}
-
-impl_prototype!(DomainPrototype: DomainPredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/mod.rs b/crates/iroha_data_model/src/query/predicate/prototypes/mod.rs
deleted file mode 100644
index 0bede28ec3c..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/mod.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-//! This module contains prototypes for all types predicates can be applied to. The prototypes are used to construct predicates.
-//!
-//! The prototypes are zero-sized types that mimic the shape of objects in the data model, allowing for an ergonomic way to construct predicates.
-
-pub mod account;
-pub mod asset;
-pub mod block;
-pub mod domain;
-pub mod parameter;
-pub mod peer;
-pub mod permission;
-pub mod role;
-pub mod trigger;
-
-#[cfg(not(feature = "std"))]
-use alloc::string::String;
-use core::marker::PhantomData;
-
-use iroha_crypto::PublicKey;
-
-use super::{projectors::ObjectProjector, AstPredicate, HasPrototype};
-use crate::query::predicate::predicate_atoms::{
-    MetadataPredicateBox, PublicKeyPredicateBox, StringPredicateBox,
-};
-
-macro_rules! impl_prototype {
-    ($prototype:ident: $predicate:ty) => {
-        impl<Projector> $prototype<Projector>
-        where
-            Projector: ObjectProjector<Input = $predicate>,
-        {
-            /// Creates a predicate that delegates to the given predicate.
-            pub fn satisfies<P>(&self, predicate: P) -> Projector::ProjectedPredicate<P>
-            where
-                P: AstPredicate<$predicate>,
-            {
-                Projector::project_predicate(predicate)
-            }
-        }
-
-        impl HasPrototype for $predicate {
-            type Prototype<Projector: Default> = $prototype<Projector>;
-        }
-    };
-}
-pub(crate) use impl_prototype;
-
-/// A prototype of [`String`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct StringPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(StringPrototype: StringPredicateBox);
-
-impl<Projector> StringPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = StringPredicateBox>,
-{
-    /// Creates a predicate that checks if the string is equal to the expected value.
-    pub fn eq(
-        &self,
-        expected: impl Into<String>,
-    ) -> Projector::ProjectedPredicate<StringPredicateBox> {
-        Projector::project_predicate(StringPredicateBox::Equals(expected.into()))
-    }
-
-    /// Creates a predicate that checks if the string contains the expected value.
-    pub fn contains(
-        &self,
-        expected: impl Into<String>,
-    ) -> Projector::ProjectedPredicate<StringPredicateBox> {
-        Projector::project_predicate(StringPredicateBox::Contains(expected.into()))
-    }
-
-    /// Creates a predicate that checks if the string starts with the expected value.
-    pub fn starts_with(
-        &self,
-        expected: impl Into<String>,
-    ) -> Projector::ProjectedPredicate<StringPredicateBox> {
-        Projector::project_predicate(StringPredicateBox::StartsWith(expected.into()))
-    }
-
-    /// Creates a predicate that checks if the string ends with the expected value.
-    pub fn ends_with(
-        &self,
-        expected: impl Into<String>,
-    ) -> Projector::ProjectedPredicate<StringPredicateBox> {
-        Projector::project_predicate(StringPredicateBox::EndsWith(expected.into()))
-    }
-}
-
-/// A prototype of [`crate::metadata::Metadata`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct MetadataPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(MetadataPrototype: MetadataPredicateBox);
-
-/// A prototype of [`PublicKey`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct PublicKeyPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-
-impl_prototype!(PublicKeyPrototype: PublicKeyPredicateBox);
-
-impl<Projector> PublicKeyPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = PublicKeyPredicateBox>,
-{
-    /// Creates a predicate that checks if the public key is equal to the expected value.
-    pub fn eq(&self, expected: PublicKey) -> Projector::ProjectedPredicate<PublicKeyPredicateBox> {
-        Projector::project_predicate(PublicKeyPredicateBox::Equals(expected))
-    }
-}
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/parameter.rs b/crates/iroha_data_model/src/query/predicate/prototypes/parameter.rs
deleted file mode 100644
index 6044e05441f..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/parameter.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::parameter`].
-
-use core::marker::PhantomData;
-
-use super::impl_prototype;
-use crate::query::{
-    predicate::{predicate_atoms::parameter::ParameterPredicateBox, projectors::ObjectProjector},
-    AstPredicate, HasPrototype,
-};
-
-/// A prototype of [`crate::parameter::Parameter`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct ParameterPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-impl_prototype!(ParameterPrototype: ParameterPredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/peer.rs b/crates/iroha_data_model/src/query/predicate/prototypes/peer.rs
deleted file mode 100644
index da12cdcc092..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/peer.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::peer`].
-
-use core::marker::PhantomData;
-
-use super::impl_prototype;
-use crate::query::{
-    predicate::{predicate_atoms::peer::PeerPredicateBox, projectors::ObjectProjector},
-    AstPredicate, HasPrototype,
-};
-
-/// A prototype of [`crate::peer::Peer`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct PeerPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-impl_prototype!(PeerPrototype: PeerPredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/permission.rs b/crates/iroha_data_model/src/query/predicate/prototypes/permission.rs
deleted file mode 100644
index 9f91121b452..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/permission.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::permission`].
-
-use core::marker::PhantomData;
-
-use super::impl_prototype;
-use crate::query::{
-    predicate::{predicate_atoms::permission::PermissionPredicateBox, projectors::ObjectProjector},
-    AstPredicate, HasPrototype,
-};
-
-/// A prototype of [`crate::permission::Permission`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct PermissionPrototype<Projector> {
-    phantom: PhantomData<Projector>,
-}
-impl_prototype!(PermissionPrototype: PermissionPredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/role.rs b/crates/iroha_data_model/src/query/predicate/prototypes/role.rs
deleted file mode 100644
index 309ea2f48a8..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/role.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::role`].
-
-use super::impl_prototype;
-use crate::{
-    query::predicate::{
-        predicate_atoms::role::{RoleIdPredicateBox, RolePredicateBox},
-        projectors::{ObjectProjector, RoleIdNameProjector, RoleIdProjector},
-        prototypes::StringPrototype,
-        AstPredicate, HasPrototype,
-    },
-    role::RoleId,
-};
-
-/// A prototype of [`RoleId`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct RoleIdPrototype<Projector> {
-    /// Build a predicate on name of this [`RoleId`].
-    pub name: StringPrototype<RoleIdNameProjector<Projector>>,
-}
-
-impl_prototype!(RoleIdPrototype: RoleIdPredicateBox);
-
-impl<Projector> RoleIdPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = RoleIdPredicateBox>,
-{
-    /// Creates a predicate that checks if the role ID is equal to the expected value.
-    pub fn eq(&self, expected: RoleId) -> Projector::ProjectedPredicate<RoleIdPredicateBox> {
-        Projector::project_predicate(RoleIdPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`crate::role::Role`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct RolePrototype<Projector> {
-    /// Build a predicate on ID of this [`crate::role::Role`].
-    pub id: RoleIdPrototype<RoleIdProjector<Projector>>,
-}
-
-impl_prototype!(RolePrototype: RolePredicateBox);
diff --git a/crates/iroha_data_model/src/query/predicate/prototypes/trigger.rs b/crates/iroha_data_model/src/query/predicate/prototypes/trigger.rs
deleted file mode 100644
index 9ee8c29c044..00000000000
--- a/crates/iroha_data_model/src/query/predicate/prototypes/trigger.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! Account-related prototypes, mirroring types in [`crate::trigger`].
-
-use super::impl_prototype;
-use crate::{
-    prelude::TriggerId,
-    query::predicate::{
-        predicate_atoms::trigger::{TriggerIdPredicateBox, TriggerPredicateBox},
-        projectors::{ObjectProjector, TriggerIdProjector},
-        prototypes::StringPrototype,
-        AstPredicate, HasPrototype,
-    },
-};
-
-/// A prototype of [`TriggerId`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct TriggerIdPrototype<Projector> {
-    /// Build a predicate on name of this [`TriggerId`]
-    pub name: StringPrototype<TriggerIdProjector<Projector>>,
-}
-
-impl_prototype!(TriggerIdPrototype: TriggerIdPredicateBox);
-
-impl<Projector> TriggerIdPrototype<Projector>
-where
-    Projector: ObjectProjector<Input = TriggerIdPredicateBox>,
-{
-    /// Creates a predicate that checks if the trigger ID is equal to the expected value.
-    pub fn eq(&self, expected: TriggerId) -> Projector::ProjectedPredicate<TriggerIdPredicateBox> {
-        Projector::project_predicate(TriggerIdPredicateBox::Equals(expected))
-    }
-}
-
-/// A prototype of [`crate::trigger::Trigger`] for predicate construction.
-#[derive(Default, Copy, Clone)]
-pub struct TriggerPrototype<Projector> {
-    /// Build a predicate on ID of this [`crate::trigger::Trigger`]
-    pub id: TriggerIdPrototype<TriggerIdProjector<Projector>>,
-}
-
-impl_prototype!(TriggerPrototype: TriggerPredicateBox);
diff --git a/crates/iroha_data_model/src/visit.rs b/crates/iroha_data_model/src/visit.rs
index dae06cd82cd..bd4f163bd85 100644
--- a/crates/iroha_data_model/src/visit.rs
+++ b/crates/iroha_data_model/src/visit.rs
@@ -7,7 +7,7 @@ use crate::{
     isi::Log,
     prelude::*,
     query::{
-        trigger::FindTriggers, AnyQueryBox, QueryWithFilterFor, QueryWithParams, SingularQueryBox,
+        trigger::FindTriggers, AnyQueryBox, QueryWithFilter, QueryWithParams, SingularQueryBox,
     },
 };
 
@@ -62,21 +62,21 @@ pub trait Visit {
         visit_find_trigger_metadata(&FindTriggerMetadata),
 
         // Visit IterableQueryBox
-        visit_find_domains(&QueryWithFilterFor<FindDomains>),
-        visit_find_accounts(&QueryWithFilterFor<FindAccounts>),
-        visit_find_assets(&QueryWithFilterFor<FindAssets>),
-        visit_find_assets_definitions(&QueryWithFilterFor<FindAssetsDefinitions>),
-        visit_find_roles(&QueryWithFilterFor<FindRoles>),
-        visit_find_role_ids(&QueryWithFilterFor<FindRoleIds>),
-        visit_find_permissions_by_account_id(&QueryWithFilterFor<FindPermissionsByAccountId>),
-        visit_find_roles_by_account_id(&QueryWithFilterFor<FindRolesByAccountId>),
-        visit_find_accounts_with_asset(&QueryWithFilterFor<FindAccountsWithAsset>),
-        visit_find_peers(&QueryWithFilterFor<FindPeers>),
-        visit_find_active_trigger_ids(&QueryWithFilterFor<FindActiveTriggerIds>),
-        visit_find_triggers(&QueryWithFilterFor<FindTriggers>),
-        visit_find_transactions(&QueryWithFilterFor<FindTransactions>),
-        visit_find_blocks(&QueryWithFilterFor<FindBlocks>),
-        visit_find_block_headers(&QueryWithFilterFor<FindBlockHeaders>),
+        visit_find_domains(&QueryWithFilter<FindDomains>),
+        visit_find_accounts(&QueryWithFilter<FindAccounts>),
+        visit_find_assets(&QueryWithFilter<FindAssets>),
+        visit_find_assets_definitions(&QueryWithFilter<FindAssetsDefinitions>),
+        visit_find_roles(&QueryWithFilter<FindRoles>),
+        visit_find_role_ids(&QueryWithFilter<FindRoleIds>),
+        visit_find_permissions_by_account_id(&QueryWithFilter<FindPermissionsByAccountId>),
+        visit_find_roles_by_account_id(&QueryWithFilter<FindRolesByAccountId>),
+        visit_find_accounts_with_asset(&QueryWithFilter<FindAccountsWithAsset>),
+        visit_find_peers(&QueryWithFilter<FindPeers>),
+        visit_find_active_trigger_ids(&QueryWithFilter<FindActiveTriggerIds>),
+        visit_find_triggers(&QueryWithFilter<FindTriggers>),
+        visit_find_transactions(&QueryWithFilter<FindTransactions>),
+        visit_find_blocks(&QueryWithFilter<FindBlocks>),
+        visit_find_block_headers(&QueryWithFilter<FindBlockHeaders>),
 
         // Visit RegisterBox
         visit_register_peer(&Register<Peer>),
@@ -386,19 +386,19 @@ leaf_visitors! {
     visit_find_trigger_metadata(&FindTriggerMetadata),
 
     // Iterable Query visitors
-    visit_find_domains(&QueryWithFilterFor<FindDomains>),
-    visit_find_accounts(&QueryWithFilterFor<FindAccounts>),
-    visit_find_assets(&QueryWithFilterFor<FindAssets>),
-    visit_find_assets_definitions(&QueryWithFilterFor<FindAssetsDefinitions>),
-    visit_find_roles(&QueryWithFilterFor<FindRoles>),
-    visit_find_role_ids(&QueryWithFilterFor<FindRoleIds>),
-    visit_find_permissions_by_account_id(&QueryWithFilterFor<FindPermissionsByAccountId>),
-    visit_find_roles_by_account_id(&QueryWithFilterFor<FindRolesByAccountId>),
-    visit_find_accounts_with_asset(&QueryWithFilterFor<FindAccountsWithAsset>),
-    visit_find_peers(&QueryWithFilterFor<FindPeers>),
-    visit_find_active_trigger_ids(&QueryWithFilterFor<FindActiveTriggerIds>),
-    visit_find_triggers(&QueryWithFilterFor<FindTriggers>),
-    visit_find_transactions(&QueryWithFilterFor<FindTransactions>),
-    visit_find_blocks(&QueryWithFilterFor<FindBlocks>),
-    visit_find_block_headers(&QueryWithFilterFor<FindBlockHeaders>),
+    visit_find_domains(&QueryWithFilter<FindDomains>),
+    visit_find_accounts(&QueryWithFilter<FindAccounts>),
+    visit_find_assets(&QueryWithFilter<FindAssets>),
+    visit_find_assets_definitions(&QueryWithFilter<FindAssetsDefinitions>),
+    visit_find_roles(&QueryWithFilter<FindRoles>),
+    visit_find_role_ids(&QueryWithFilter<FindRoleIds>),
+    visit_find_permissions_by_account_id(&QueryWithFilter<FindPermissionsByAccountId>),
+    visit_find_roles_by_account_id(&QueryWithFilter<FindRolesByAccountId>),
+    visit_find_accounts_with_asset(&QueryWithFilter<FindAccountsWithAsset>),
+    visit_find_peers(&QueryWithFilter<FindPeers>),
+    visit_find_active_trigger_ids(&QueryWithFilter<FindActiveTriggerIds>),
+    visit_find_triggers(&QueryWithFilter<FindTriggers>),
+    visit_find_transactions(&QueryWithFilter<FindTransactions>),
+    visit_find_blocks(&QueryWithFilter<FindBlocks>),
+    visit_find_block_headers(&QueryWithFilter<FindBlockHeaders>),
 }
diff --git a/crates/iroha_executor/src/permission.rs b/crates/iroha_executor/src/permission.rs
index e5ef2a51b6c..c9c3c92edc1 100644
--- a/crates/iroha_executor/src/permission.rs
+++ b/crates/iroha_executor/src/permission.rs
@@ -151,7 +151,7 @@ pub trait ExecutorPermission: Permission + PartialEq {
             .expect("INTERNAL BUG: `FindRolesByAccountId` must never fail")
             .map(|role_id| role_id.dbg_expect("Failed to get role from cursor"))
             .fold(CompoundPredicate::Or(Vec::new()), |predicate, role_id| {
-                predicate.or(RolePredicateBox::build(|role| role.id.eq(role_id)))
+                predicate.or(CompoundPredicate::<Role>::build(|role| role.id.eq(role_id)))
             });
 
         // check if any of the roles have the permission we need
diff --git a/crates/iroha_schema/src/lib.rs b/crates/iroha_schema/src/lib.rs
index 45c9e78c5e6..cd628a7596f 100644
--- a/crates/iroha_schema/src/lib.rs
+++ b/crates/iroha_schema/src/lib.rs
@@ -280,6 +280,22 @@ pub struct BitmapMask {
 #[derive(Debug, Clone, Serialize)]
 pub struct Compact<T>(T);
 
+impl TypeId for () {
+    fn id() -> String {
+        "()".to_owned()
+    }
+}
+impl IntoSchema for () {
+    fn type_name() -> String {
+        "()".to_owned()
+    }
+    fn update_schema_map(map: &mut MetaMap) {
+        if !map.contains_key::<Self>() {
+            map.insert::<Self>(Metadata::Tuple(UnnamedFieldsMeta { types: vec![] }));
+        }
+    }
+}
+
 macro_rules! impl_schema_int {
     ($($t:ty),*) => {$(
         impl TypeId for $t {
diff --git a/crates/iroha_schema_gen/src/lib.rs b/crates/iroha_schema_gen/src/lib.rs
index 82fa07d5d93..ea09d3ce920 100644
--- a/crates/iroha_schema_gen/src/lib.rs
+++ b/crates/iroha_schema_gen/src/lib.rs
@@ -115,9 +115,13 @@ types!(
     AccountEventFilter,
     AccountEventSet,
     AccountId,
-    AccountIdPredicateBox,
+    AccountIdPredicateAtom,
+    AccountIdProjection<PredicateMarker>,
+    AccountIdProjection<SelectorMarker>,
     AccountPermissionChanged,
-    AccountPredicateBox,
+    AccountPredicateAtom,
+    AccountProjection<PredicateMarker>,
+    AccountProjection<SelectorMarker>,
     AccountRoleChanged,
     Action,
     Algorithm,
@@ -128,20 +132,30 @@ types!(
     AssetDefinitionEventFilter,
     AssetDefinitionEventSet,
     AssetDefinitionId,
-    AssetDefinitionIdPredicateBox,
+    AssetDefinitionIdPredicateAtom,
+    AssetDefinitionIdProjection<PredicateMarker>,
+    AssetDefinitionIdProjection<SelectorMarker>,
     AssetDefinitionOwnerChanged,
-    AssetDefinitionPredicateBox,
+    AssetDefinitionPredicateAtom,
+    AssetDefinitionProjection<PredicateMarker>,
+    AssetDefinitionProjection<SelectorMarker>,
     AssetDefinitionTotalQuantityChanged,
     AssetEvent,
     AssetEventFilter,
     AssetEventSet,
     AssetId,
-    AssetIdPredicateBox,
-    AssetPredicateBox,
+    AssetIdPredicateAtom,
+    AssetIdProjection<PredicateMarker>,
+    AssetIdProjection<SelectorMarker>,
+    AssetPredicateAtom,
+    AssetProjection<PredicateMarker>,
+    AssetProjection<SelectorMarker>,
     AssetTransferBox,
     AssetType,
     AssetValue,
-    AssetValuePredicateBox,
+    AssetValuePredicateAtom,
+    AssetValueProjection<PredicateMarker>,
+    AssetValueProjection<SelectorMarker>,
     BTreeMap<AccountId, u8>,
     BTreeMap<CustomParameterId, CustomParameter>,
     BTreeMap<Name, Json>,
@@ -150,9 +164,13 @@ types!(
     BTreeSet<String>,
     BlockEvent,
     BlockEventFilter,
-    BlockHashPredicateBox,
+    BlockHeaderHashPredicateAtom,
+    BlockHeaderHashProjection<PredicateMarker>,
+    BlockHeaderHashProjection<SelectorMarker>,
     BlockHeader,
-    BlockHeaderPredicateBox,
+    BlockHeaderPredicateAtom,
+    BlockHeaderProjection<PredicateMarker>,
+    BlockHeaderProjection<SelectorMarker>,
     BlockMessage,
     BlockParameter,
     BlockParameters,
@@ -161,39 +179,41 @@ types!(
     BlockSignature,
     BlockStatus,
     BlockSubscriptionRequest,
-    Box<CompoundPredicate<AccountPredicateBox>>,
-    Box<CompoundPredicate<AssetDefinitionPredicateBox>>,
-    Box<CompoundPredicate<AssetPredicateBox>>,
-    Box<CompoundPredicate<BlockHeaderPredicateBox>>,
-    Box<CompoundPredicate<CommittedTransactionPredicateBox>>,
-    Box<CompoundPredicate<DomainPredicateBox>>,
-    Box<CompoundPredicate<PeerPredicateBox>>,
-    Box<CompoundPredicate<PermissionPredicateBox>>,
-    Box<CompoundPredicate<RoleIdPredicateBox>>,
-    Box<CompoundPredicate<RolePredicateBox>>,
-    Box<CompoundPredicate<SignedBlockPredicateBox>>,
-    Box<CompoundPredicate<TriggerIdPredicateBox>>,
-    Box<CompoundPredicate<TriggerPredicateBox>>,
+    Box<CompoundPredicate<Account>>,
+    Box<CompoundPredicate<AssetDefinition>>,
+    Box<CompoundPredicate<Asset>>,
+    Box<CompoundPredicate<BlockHeader>>,
+    Box<CompoundPredicate<CommittedTransaction>>,
+    Box<CompoundPredicate<Domain>>,
+    Box<CompoundPredicate<PeerId>>,
+    Box<CompoundPredicate<Permission>>,
+    Box<CompoundPredicate<RoleId>>,
+    Box<CompoundPredicate<Role>>,
+    Box<CompoundPredicate<SignedBlock>>,
+    Box<CompoundPredicate<TriggerId>>,
+    Box<CompoundPredicate<Trigger>>,
     Box<TransactionRejectionReason>,
     Burn<Numeric, Asset>,
     Burn<u32, Trigger>,
     BurnBox,
     ChainId,
     CommittedTransaction,
-    CommittedTransactionPredicateBox,
-    CompoundPredicate<AccountPredicateBox>,
-    CompoundPredicate<AssetDefinitionPredicateBox>,
-    CompoundPredicate<AssetPredicateBox>,
-    CompoundPredicate<BlockHeaderPredicateBox>,
-    CompoundPredicate<CommittedTransactionPredicateBox>,
-    CompoundPredicate<DomainPredicateBox>,
-    CompoundPredicate<PeerPredicateBox>,
-    CompoundPredicate<PermissionPredicateBox>,
-    CompoundPredicate<RoleIdPredicateBox>,
-    CompoundPredicate<RolePredicateBox>,
-    CompoundPredicate<SignedBlockPredicateBox>,
-    CompoundPredicate<TriggerIdPredicateBox>,
-    CompoundPredicate<TriggerPredicateBox>,
+    CommittedTransactionPredicateAtom,
+    CommittedTransactionProjection<PredicateMarker>,
+    CommittedTransactionProjection<SelectorMarker>,
+    CompoundPredicate<Account>,
+    CompoundPredicate<AssetDefinition>,
+    CompoundPredicate<Asset>,
+    CompoundPredicate<BlockHeader>,
+    CompoundPredicate<CommittedTransaction>,
+    CompoundPredicate<Domain>,
+    CompoundPredicate<PeerId>,
+    CompoundPredicate<Permission>,
+    CompoundPredicate<RoleId>,
+    CompoundPredicate<Role>,
+    CompoundPredicate<SignedBlock>,
+    CompoundPredicate<TriggerId>,
+    CompoundPredicate<Trigger>,
     ConfigurationEvent,
     ConfigurationEventFilter,
     ConfigurationEventSet,
@@ -210,9 +230,13 @@ types!(
     DomainEventFilter,
     DomainEventSet,
     DomainId,
-    DomainIdPredicateBox,
+    DomainIdPredicateAtom,
+    DomainIdProjection<PredicateMarker>,
+    DomainIdProjection<SelectorMarker>,
     DomainOwnerChanged,
-    DomainPredicateBox,
+    DomainPredicateAtom,
+    DomainProjection<PredicateMarker>,
+    DomainProjection<SelectorMarker>,
     EventBox,
     EventFilterBox,
     EventMessage,
@@ -287,7 +311,9 @@ types!(
     MetadataChanged<AssetId>,
     MetadataChanged<DomainId>,
     MetadataChanged<TriggerId>,
-    MetadataPredicateBox,
+    MetadataPredicateAtom,
+    MetadataProjection<PredicateMarker>,
+    MetadataProjection<SelectorMarker>,
     Mint<Numeric, Asset>,
     Mint<u32, Trigger>,
     MintBox,
@@ -295,6 +321,8 @@ types!(
     Mintable,
     Mismatch<AssetType>,
     Name,
+    NameProjection<PredicateMarker>,
+    NameProjection<SelectorMarker>,
     NewAccount,
     NewAssetDefinition,
     NewDomain,
@@ -335,37 +363,44 @@ types!(
     PeerEventSet,
     Peer,
     PeerId,
-    PeerPredicateBox,
+    PeerIdPredicateAtom,
+    PeerIdProjection<PredicateMarker>,
+    PeerIdProjection<SelectorMarker>,
     Permission,
-    PermissionPredicateBox,
+    PermissionPredicateAtom,
+    PermissionProjection<PredicateMarker>,
+    PermissionProjection<SelectorMarker>,
     PipelineEventBox,
     PipelineEventFilterBox,
     PublicKey,
-    PublicKeyPredicateBox,
+    PublicKeyPredicateAtom,
+    PublicKeyProjection<PredicateMarker>,
+    PublicKeyProjection<SelectorMarker>,
     QueryBox,
     QueryExecutionFail,
     QueryOutput,
     QueryOutputBatchBox,
+    QueryOutputBatchBoxTuple,
     QueryParams,
     QueryRequest,
     QueryRequestWithAuthority,
     QueryResponse,
     QuerySignature,
-    QueryWithFilter<FindAccounts, AccountPredicateBox>,
-    QueryWithFilter<FindAccountsWithAsset, AccountPredicateBox>,
-    QueryWithFilter<FindActiveTriggerIds, TriggerIdPredicateBox>,
-    QueryWithFilter<FindAssets, AssetPredicateBox>,
-    QueryWithFilter<FindAssetsDefinitions, AssetDefinitionPredicateBox>,
-    QueryWithFilter<FindBlockHeaders, BlockHeaderPredicateBox>,
-    QueryWithFilter<FindBlocks, SignedBlockPredicateBox>,
-    QueryWithFilter<FindDomains, DomainPredicateBox>,
-    QueryWithFilter<FindPeers, PeerPredicateBox>,
-    QueryWithFilter<FindPermissionsByAccountId, PermissionPredicateBox>,
-    QueryWithFilter<FindRoleIds, RoleIdPredicateBox>,
-    QueryWithFilter<FindRoles, RolePredicateBox>,
-    QueryWithFilter<FindRolesByAccountId, RoleIdPredicateBox>,
-    QueryWithFilter<FindTransactions, CommittedTransactionPredicateBox>,
-    QueryWithFilter<FindTriggers, TriggerPredicateBox>,
+    QueryWithFilter<FindAccounts>,
+    QueryWithFilter<FindAccountsWithAsset>,
+    QueryWithFilter<FindActiveTriggerIds>,
+    QueryWithFilter<FindAssets>,
+    QueryWithFilter<FindAssetsDefinitions>,
+    QueryWithFilter<FindBlockHeaders>,
+    QueryWithFilter<FindBlocks>,
+    QueryWithFilter<FindDomains>,
+    QueryWithFilter<FindPeers>,
+    QueryWithFilter<FindPermissionsByAccountId>,
+    QueryWithFilter<FindRoleIds>,
+    QueryWithFilter<FindRoles>,
+    QueryWithFilter<FindRolesByAccountId>,
+    QueryWithFilter<FindTransactions>,
+    QueryWithFilter<FindTriggers>,
     QueryWithParams,
     Register<Account>,
     Register<Asset>,
@@ -392,9 +427,26 @@ types!(
     RoleEventFilter,
     RoleEventSet,
     RoleId,
-    RoleIdPredicateBox,
+    RoleIdPredicateAtom,
+    RoleIdProjection<PredicateMarker>,
+    RoleIdProjection<SelectorMarker>,
     RolePermissionChanged,
-    RolePredicateBox,
+    RolePredicateAtom,
+    RoleProjection<PredicateMarker>,
+    RoleProjection<SelectorMarker>,
+    SelectorTuple<Account>,
+    SelectorTuple<AssetDefinition>,
+    SelectorTuple<Asset>,
+    SelectorTuple<BlockHeader>,
+    SelectorTuple<CommittedTransaction>,
+    SelectorTuple<Domain>,
+    SelectorTuple<PeerId>,
+    SelectorTuple<Permission>,
+    SelectorTuple<RoleId>,
+    SelectorTuple<Role>,
+    SelectorTuple<SignedBlock>,
+    SelectorTuple<TriggerId>,
+    SelectorTuple<Trigger>,
     SetKeyValue<Account>,
     SetKeyValue<Asset>,
     SetKeyValue<AssetDefinition>,
@@ -407,12 +459,16 @@ types!(
     SignatureOf<QueryRequestWithAuthority>,
     SignatureOf<TransactionPayload>,
     SignedBlock,
-    SignedBlockPredicateBox,
+    SignedBlockPredicateAtom,
+    SignedBlockProjection<PredicateMarker>,
+    SignedBlockProjection<SelectorMarker>,
     SignedBlockV1,
     SignedQuery,
     SignedQueryV1,
     SignedTransaction,
-    SignedTransactionPredicateBox,
+    SignedTransactionPredicateAtom,
+    SignedTransactionProjection<PredicateMarker>,
+    SignedTransactionProjection<SelectorMarker>,
     SignedTransactionV1,
     SingularQueryBox,
     SingularQueryOutputBox,
@@ -424,17 +480,21 @@ types!(
     SocketAddrV6,
     Sorting,
     String,
-    StringPredicateBox,
+    StringPredicateAtom,
     SumeragiParameter,
     SumeragiParameters,
     TimeEvent,
     TimeEventFilter,
     TimeInterval,
     TimeSchedule,
-    TransactionErrorPredicateBox,
+    TransactionErrorPredicateAtom,
+    TransactionErrorProjection<PredicateMarker>,
+    TransactionErrorProjection<SelectorMarker>,
     TransactionEvent,
     TransactionEventFilter,
-    TransactionHashPredicateBox,
+    TransactionHashPredicateAtom,
+    TransactionHashProjection<PredicateMarker>,
+    TransactionHashProjection<SelectorMarker>,
     TransactionLimitError,
     TransactionParameter,
     TransactionParameters,
@@ -456,9 +516,13 @@ types!(
     TriggerEventFilter,
     TriggerEventSet,
     TriggerId,
-    TriggerIdPredicateBox,
+    TriggerIdPredicateAtom,
+    TriggerIdProjection<PredicateMarker>,
+    TriggerIdProjection<SelectorMarker>,
     TriggerNumberOfExecutionsChanged,
-    TriggerPredicateBox,
+    TriggerPredicateAtom,
+    TriggerProjection<PredicateMarker>,
+    TriggerProjection<SelectorMarker>,
     TypeError,
     Unregister<Account>,
     Unregister<Asset>,
@@ -471,41 +535,68 @@ types!(
     Upgrade,
     ValidationFail,
     Vec<Account>,
+    Vec<AccountId>,
     Vec<Asset>,
+    Vec<AssetId>,
     Vec<AssetDefinition>,
+    Vec<AssetDefinitionId>,
+    Vec<AssetValue>,
     Vec<BlockHeader>,
     Vec<BlockSignature>,
     Vec<CommittedTransaction>,
-    Vec<CompoundPredicate<AccountPredicateBox>>,
-    Vec<CompoundPredicate<AssetDefinitionPredicateBox>>,
-    Vec<CompoundPredicate<AssetPredicateBox>>,
-    Vec<CompoundPredicate<BlockHeaderPredicateBox>>,
-    Vec<CompoundPredicate<CommittedTransactionPredicateBox>>,
-    Vec<CompoundPredicate<DomainPredicateBox>>,
-    Vec<CompoundPredicate<PeerPredicateBox>>,
-    Vec<CompoundPredicate<PermissionPredicateBox>>,
-    Vec<CompoundPredicate<RoleIdPredicateBox>>,
-    Vec<CompoundPredicate<RolePredicateBox>>,
-    Vec<CompoundPredicate<SignedBlockPredicateBox>>,
-    Vec<CompoundPredicate<TriggerIdPredicateBox>>,
-    Vec<CompoundPredicate<TriggerPredicateBox>>,
+    Vec<CompoundPredicate<Account>>,
+    Vec<CompoundPredicate<AssetDefinition>>,
+    Vec<CompoundPredicate<Asset>>,
+    Vec<CompoundPredicate<BlockHeader>>,
+    Vec<CompoundPredicate<CommittedTransaction>>,
+    Vec<CompoundPredicate<Domain>>,
+    Vec<CompoundPredicate<PeerId>>,
+    Vec<CompoundPredicate<Permission>>,
+    Vec<CompoundPredicate<RoleId>>,
+    Vec<CompoundPredicate<Role>>,
+    Vec<CompoundPredicate<SignedBlock>>,
+    Vec<CompoundPredicate<TriggerId>>,
+    Vec<CompoundPredicate<Trigger>>,
     Vec<Domain>,
+    Vec<DomainId>,
     Vec<EventFilterBox>,
     Vec<GenesisWasmTrigger>,
     Vec<InstructionBox>,
     Vec<Parameter>,
     Vec<PeerId>,
     Vec<Permission>,
+    Vec<QueryOutputBatchBox>,
     Vec<Role>,
     Vec<RoleId>,
     Vec<SignedBlock>,
     Vec<SignedTransaction>,
+    Vec<AccountProjection<SelectorMarker>>,
+    Vec<AssetDefinitionProjection<SelectorMarker>>,
+    Vec<AssetProjection<SelectorMarker>>,
+    Vec<BlockHeaderProjection<SelectorMarker>>,
+    Vec<CommittedTransactionProjection<SelectorMarker>>,
+    Vec<DomainProjection<SelectorMarker>>,
+    Vec<HashOf<BlockHeader>>,
+    Vec<HashOf<SignedTransaction>>,
+    Vec<Metadata>,
+    Vec<Name>,
+    Vec<Option<TransactionRejectionReason>>,
+    Vec<PeerIdProjection<SelectorMarker>>,
+    Vec<PermissionProjection<SelectorMarker>>,
+    Vec<PublicKey>,
+    Vec<RoleIdProjection<SelectorMarker>>,
+    Vec<RoleProjection<SelectorMarker>>,
+    Vec<SignedBlockProjection<SelectorMarker>>,
+    Vec<String>,
+    Vec<TriggerIdProjection<SelectorMarker>>,
+    Vec<TriggerProjection<SelectorMarker>>,
     Vec<Trigger>,
     Vec<TriggerId>,
     Vec<u8>,
     WasmExecutionFail,
     WasmSmartContract,
 
+    (),
     [u16; 8],
     [u8; 4],
     [u8; 32],
@@ -550,12 +641,12 @@ pub mod complete_data_model {
         },
         prelude::*,
         query::{
+            dsl::{CompoundPredicate, PredicateMarker, SelectorMarker},
             error::{FindError, QueryExecutionFail},
             parameters::{ForwardCursor, QueryParams},
-            predicate::CompoundPredicate,
-            CommittedTransaction, QueryOutput, QueryOutputBatchBox, QueryRequestWithAuthority,
-            QueryResponse, QuerySignature, QueryWithFilter, QueryWithParams, SignedQuery,
-            SignedQueryV1, SingularQueryOutputBox,
+            CommittedTransaction, QueryOutput, QueryOutputBatchBox, QueryOutputBatchBoxTuple,
+            QueryRequestWithAuthority, QueryResponse, QuerySignature, QueryWithFilter,
+            QueryWithParams, SignedQuery, SignedQueryV1, SingularQueryOutputBox,
         },
         transaction::{
             error::TransactionLimitError, SignedTransactionV1, TransactionPayload,
diff --git a/crates/iroha_smart_contract/src/lib.rs b/crates/iroha_smart_contract/src/lib.rs
index d9754948ad9..99f75872704 100644
--- a/crates/iroha_smart_contract/src/lib.rs
+++ b/crates/iroha_smart_contract/src/lib.rs
@@ -17,8 +17,7 @@ use data_model::{
 pub use iroha_data_model as data_model;
 use iroha_data_model::query::{
     builder::{QueryBuilder, QueryExecutor},
-    predicate::HasPredicateBox,
-    QueryOutputBatchBox, QueryRequest, QueryResponse, QueryWithParams, SingularQuery,
+    QueryOutputBatchBoxTuple, QueryRequest, QueryResponse, QueryWithParams, SingularQuery,
     SingularQueryBox, SingularQueryOutputBox,
 };
 pub use iroha_smart_contract_derive::main;
@@ -100,10 +99,7 @@ impl Iroha {
     }
 
     /// Build an iterable query for execution in a smart contract.
-    pub fn query<Q>(
-        &self,
-        query: Q,
-    ) -> QueryBuilder<Self, Q, <<Q as Query>::Item as HasPredicateBox>::PredicateBoxType>
+    pub fn query<Q>(&self, query: Q) -> QueryBuilder<Self, Q, Q::Item>
     where
         Q: Query,
     {
@@ -164,7 +160,7 @@ impl QueryExecutor for Iroha {
     fn start_query(
         &self,
         query: QueryWithParams,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<Self::Cursor>), Self::Error> {
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<Self::Cursor>), Self::Error> {
         let QueryResponse::Iterable(output) = Self::execute_query(&QueryRequest::Start(query))?
         else {
             dbg_panic!("BUG: iroha returned unexpected type in iterable query");
@@ -181,7 +177,7 @@ impl QueryExecutor for Iroha {
 
     fn continue_query(
         cursor: Self::Cursor,
-    ) -> Result<(QueryOutputBatchBox, u64, Option<Self::Cursor>), Self::Error> {
+    ) -> Result<(QueryOutputBatchBoxTuple, u64, Option<Self::Cursor>), Self::Error> {
         let QueryResponse::Iterable(output) =
             Self::execute_query(&QueryRequest::Continue(cursor.cursor))?
         else {
diff --git a/docs/source/references/schema.json b/docs/source/references/schema.json
index 49dbe788535..78dadd174c0 100644
--- a/docs/source/references/schema.json
+++ b/docs/source/references/schema.json
@@ -1,4 +1,5 @@
 {
+  "()": null,
   "Account": {
     "Struct": [
       {
@@ -127,22 +128,50 @@
       }
     ]
   },
-  "AccountIdPredicateBox": {
+  "AccountIdPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
         "discriminant": 0,
         "type": "AccountId"
+      }
+    ]
+  },
+  "AccountIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "AccountIdPredicateAtom"
       },
       {
-        "tag": "DomainId",
+        "tag": "Domain",
+        "discriminant": 1,
+        "type": "DomainIdProjection<PredicateMarker>"
+      },
+      {
+        "tag": "Signatory",
+        "discriminant": 2,
+        "type": "PublicKeyProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "AccountIdProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Domain",
         "discriminant": 1,
-        "type": "DomainIdPredicateBox"
+        "type": "DomainIdProjection<SelectorMarker>"
       },
       {
         "tag": "Signatory",
         "discriminant": 2,
-        "type": "PublicKeyPredicateBox"
+        "type": "PublicKeyProjection<SelectorMarker>"
       }
     ]
   },
@@ -158,17 +187,44 @@
       }
     ]
   },
-  "AccountPredicateBox": {
+  "AccountPredicateAtom": {
+    "Enum": []
+  },
+  "AccountProjection<PredicateMarker>": {
     "Enum": [
       {
-        "tag": "Id",
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "AccountIdPredicateBox"
+        "type": "AccountPredicateAtom"
+      },
+      {
+        "tag": "Id",
+        "discriminant": 1,
+        "type": "AccountIdProjection<PredicateMarker>"
       },
       {
         "tag": "Metadata",
+        "discriminant": 2,
+        "type": "MetadataProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "AccountProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Id",
         "discriminant": 1,
-        "type": "MetadataPredicateBox"
+        "type": "AccountIdProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Metadata",
+        "discriminant": 2,
+        "type": "MetadataProjection<SelectorMarker>"
       }
     ]
   },
@@ -400,22 +456,50 @@
       }
     ]
   },
-  "AssetDefinitionIdPredicateBox": {
+  "AssetDefinitionIdPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
         "discriminant": 0,
         "type": "AssetDefinitionId"
+      }
+    ]
+  },
+  "AssetDefinitionIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "AssetDefinitionIdPredicateAtom"
       },
       {
-        "tag": "DomainId",
+        "tag": "Domain",
+        "discriminant": 1,
+        "type": "DomainIdProjection<PredicateMarker>"
+      },
+      {
+        "tag": "Name",
+        "discriminant": 2,
+        "type": "NameProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "AssetDefinitionIdProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Domain",
         "discriminant": 1,
-        "type": "DomainIdPredicateBox"
+        "type": "DomainIdProjection<SelectorMarker>"
       },
       {
         "tag": "Name",
         "discriminant": 2,
-        "type": "StringPredicateBox"
+        "type": "NameProjection<SelectorMarker>"
       }
     ]
   },
@@ -431,22 +515,44 @@
       }
     ]
   },
-  "AssetDefinitionPredicateBox": {
+  "AssetDefinitionPredicateAtom": {
+    "Enum": []
+  },
+  "AssetDefinitionProjection<PredicateMarker>": {
     "Enum": [
       {
-        "tag": "Id",
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "AssetDefinitionIdPredicateBox"
+        "type": "AssetDefinitionPredicateAtom"
+      },
+      {
+        "tag": "Id",
+        "discriminant": 1,
+        "type": "AssetDefinitionIdProjection<PredicateMarker>"
       },
       {
         "tag": "Metadata",
+        "discriminant": 2,
+        "type": "MetadataProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "AssetDefinitionProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Id",
         "discriminant": 1,
-        "type": "MetadataPredicateBox"
+        "type": "AssetDefinitionIdProjection<SelectorMarker>"
       },
       {
-        "tag": "OwnedBy",
+        "tag": "Metadata",
         "discriminant": 2,
-        "type": "AccountIdPredicateBox"
+        "type": "MetadataProjection<SelectorMarker>"
       }
     ]
   },
@@ -551,36 +657,91 @@
       }
     ]
   },
-  "AssetIdPredicateBox": {
+  "AssetIdPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
         "discriminant": 0,
         "type": "AssetId"
+      }
+    ]
+  },
+  "AssetIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "AssetIdPredicateAtom"
       },
       {
-        "tag": "DefinitionId",
+        "tag": "Account",
         "discriminant": 1,
-        "type": "AssetDefinitionIdPredicateBox"
+        "type": "AccountIdProjection<PredicateMarker>"
       },
       {
-        "tag": "AccountId",
+        "tag": "Definition",
         "discriminant": 2,
-        "type": "AccountIdPredicateBox"
+        "type": "AssetDefinitionIdProjection<PredicateMarker>"
       }
     ]
   },
-  "AssetPredicateBox": {
+  "AssetIdProjection<SelectorMarker>": {
     "Enum": [
       {
-        "tag": "Id",
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Account",
+        "discriminant": 1,
+        "type": "AccountIdProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Definition",
+        "discriminant": 2,
+        "type": "AssetDefinitionIdProjection<SelectorMarker>"
+      }
+    ]
+  },
+  "AssetPredicateAtom": {
+    "Enum": []
+  },
+  "AssetProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "AssetIdPredicateBox"
+        "type": "AssetPredicateAtom"
+      },
+      {
+        "tag": "Id",
+        "discriminant": 1,
+        "type": "AssetIdProjection<PredicateMarker>"
       },
       {
         "tag": "Value",
+        "discriminant": 2,
+        "type": "AssetValueProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "AssetProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Id",
         "discriminant": 1,
-        "type": "AssetValuePredicateBox"
+        "type": "AssetIdProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Value",
+        "discriminant": 2,
+        "type": "AssetValueProjection<SelectorMarker>"
       }
     ]
   },
@@ -625,9 +786,27 @@
       }
     ]
   },
-  "AssetValuePredicateBox": {
+  "AssetValuePredicateAtom": {
     "Enum": []
   },
+  "AssetValueProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "AssetValuePredicateAtom"
+      }
+    ]
+  },
+  "AssetValueProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "BlockEvent": {
     "Struct": [
       {
@@ -652,15 +831,6 @@
       }
     ]
   },
-  "BlockHashPredicateBox": {
-    "Enum": [
-      {
-        "tag": "Equals",
-        "discriminant": 0,
-        "type": "HashOf<BlockHeader>"
-      }
-    ]
-  },
   "BlockHeader": {
     "Struct": [
       {
@@ -685,12 +855,61 @@
       }
     ]
   },
-  "BlockHeaderPredicateBox": {
+  "BlockHeaderHashPredicateAtom": {
+    "Enum": [
+      {
+        "tag": "Equals",
+        "discriminant": 0,
+        "type": "HashOf<BlockHeader>"
+      }
+    ]
+  },
+  "BlockHeaderHashProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "BlockHeaderHashPredicateAtom"
+      }
+    ]
+  },
+  "BlockHeaderHashProjection<SelectorMarker>": {
     "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
+  "BlockHeaderPredicateAtom": {
+    "Enum": []
+  },
+  "BlockHeaderProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "BlockHeaderPredicateAtom"
+      },
       {
         "tag": "Hash",
+        "discriminant": 1,
+        "type": "BlockHeaderHashProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "BlockHeaderProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "BlockHashPredicateBox"
+        "type": "()"
+      },
+      {
+        "tag": "Hash",
+        "discriminant": 1,
+        "type": "BlockHeaderHashProjection<SelectorMarker>"
       }
     ]
   },
@@ -1016,22 +1235,54 @@
       }
     ]
   },
-  "CommittedTransactionPredicateBox": {
+  "CommittedTransactionPredicateAtom": {
+    "Enum": []
+  },
+  "CommittedTransactionProjection<PredicateMarker>": {
     "Enum": [
       {
-        "tag": "BlockHash",
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "BlockHashPredicateBox"
+        "type": "CommittedTransactionPredicateAtom"
       },
       {
-        "tag": "Value",
+        "tag": "BlockHash",
         "discriminant": 1,
-        "type": "SignedTransactionPredicateBox"
+        "type": "BlockHeaderHashProjection<PredicateMarker>"
+      },
+      {
+        "tag": "Value",
+        "discriminant": 2,
+        "type": "SignedTransactionProjection<PredicateMarker>"
       },
       {
         "tag": "Error",
+        "discriminant": 3,
+        "type": "TransactionErrorProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "CommittedTransactionProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "BlockHash",
+        "discriminant": 1,
+        "type": "BlockHeaderHashProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Value",
         "discriminant": 2,
-        "type": "TransactionErrorPredicateBox"
+        "type": "SignedTransactionProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Error",
+        "discriminant": 3,
+        "type": "TransactionErrorProjection<SelectorMarker>"
       }
     ]
   },
@@ -1041,315 +1292,315 @@
   "Compact<u32>": {
     "Int": "Compact"
   },
-  "CompoundPredicate<AccountPredicateBox>": {
+  "CompoundPredicate<Account>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "AccountPredicateBox"
+        "type": "AccountProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<AccountPredicateBox>"
+        "type": "CompoundPredicate<Account>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<AccountPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Account>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<AccountPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Account>>"
       }
     ]
   },
-  "CompoundPredicate<AssetDefinitionPredicateBox>": {
+  "CompoundPredicate<Asset>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "AssetDefinitionPredicateBox"
+        "type": "AssetProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<AssetDefinitionPredicateBox>"
+        "type": "CompoundPredicate<Asset>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<AssetDefinitionPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Asset>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<AssetDefinitionPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Asset>>"
       }
     ]
   },
-  "CompoundPredicate<AssetPredicateBox>": {
+  "CompoundPredicate<AssetDefinition>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "AssetPredicateBox"
+        "type": "AssetDefinitionProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<AssetPredicateBox>"
+        "type": "CompoundPredicate<AssetDefinition>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<AssetPredicateBox>>"
+        "type": "Vec<CompoundPredicate<AssetDefinition>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<AssetPredicateBox>>"
+        "type": "Vec<CompoundPredicate<AssetDefinition>>"
       }
     ]
   },
-  "CompoundPredicate<BlockHeaderPredicateBox>": {
+  "CompoundPredicate<BlockHeader>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "BlockHeaderPredicateBox"
+        "type": "BlockHeaderProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<BlockHeaderPredicateBox>"
+        "type": "CompoundPredicate<BlockHeader>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<BlockHeaderPredicateBox>>"
+        "type": "Vec<CompoundPredicate<BlockHeader>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<BlockHeaderPredicateBox>>"
+        "type": "Vec<CompoundPredicate<BlockHeader>>"
       }
     ]
   },
-  "CompoundPredicate<CommittedTransactionPredicateBox>": {
+  "CompoundPredicate<CommittedTransaction>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "CommittedTransactionPredicateBox"
+        "type": "CommittedTransactionProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<CommittedTransactionPredicateBox>"
+        "type": "CompoundPredicate<CommittedTransaction>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<CommittedTransactionPredicateBox>>"
+        "type": "Vec<CompoundPredicate<CommittedTransaction>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<CommittedTransactionPredicateBox>>"
+        "type": "Vec<CompoundPredicate<CommittedTransaction>>"
       }
     ]
   },
-  "CompoundPredicate<DomainPredicateBox>": {
+  "CompoundPredicate<Domain>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "DomainPredicateBox"
+        "type": "DomainProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<DomainPredicateBox>"
+        "type": "CompoundPredicate<Domain>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<DomainPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Domain>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<DomainPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Domain>>"
       }
     ]
   },
-  "CompoundPredicate<PeerPredicateBox>": {
+  "CompoundPredicate<PeerId>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "PeerPredicateBox"
+        "type": "PeerIdProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<PeerPredicateBox>"
+        "type": "CompoundPredicate<PeerId>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<PeerPredicateBox>>"
+        "type": "Vec<CompoundPredicate<PeerId>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<PeerPredicateBox>>"
+        "type": "Vec<CompoundPredicate<PeerId>>"
       }
     ]
   },
-  "CompoundPredicate<PermissionPredicateBox>": {
+  "CompoundPredicate<Permission>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "PermissionPredicateBox"
+        "type": "PermissionProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<PermissionPredicateBox>"
+        "type": "CompoundPredicate<Permission>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<PermissionPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Permission>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<PermissionPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Permission>>"
       }
     ]
   },
-  "CompoundPredicate<RoleIdPredicateBox>": {
+  "CompoundPredicate<Role>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "RoleIdPredicateBox"
+        "type": "RoleProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<RoleIdPredicateBox>"
+        "type": "CompoundPredicate<Role>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<RoleIdPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Role>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<RoleIdPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Role>>"
       }
     ]
   },
-  "CompoundPredicate<RolePredicateBox>": {
+  "CompoundPredicate<RoleId>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "RolePredicateBox"
+        "type": "RoleIdProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<RolePredicateBox>"
+        "type": "CompoundPredicate<RoleId>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<RolePredicateBox>>"
+        "type": "Vec<CompoundPredicate<RoleId>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<RolePredicateBox>>"
+        "type": "Vec<CompoundPredicate<RoleId>>"
       }
     ]
   },
-  "CompoundPredicate<SignedBlockPredicateBox>": {
+  "CompoundPredicate<SignedBlock>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "SignedBlockPredicateBox"
+        "type": "SignedBlockProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<SignedBlockPredicateBox>"
+        "type": "CompoundPredicate<SignedBlock>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<SignedBlockPredicateBox>>"
+        "type": "Vec<CompoundPredicate<SignedBlock>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<SignedBlockPredicateBox>>"
+        "type": "Vec<CompoundPredicate<SignedBlock>>"
       }
     ]
   },
-  "CompoundPredicate<TriggerIdPredicateBox>": {
+  "CompoundPredicate<Trigger>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "TriggerIdPredicateBox"
+        "type": "TriggerProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<TriggerIdPredicateBox>"
+        "type": "CompoundPredicate<Trigger>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<TriggerIdPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Trigger>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<TriggerIdPredicateBox>>"
+        "type": "Vec<CompoundPredicate<Trigger>>"
       }
     ]
   },
-  "CompoundPredicate<TriggerPredicateBox>": {
+  "CompoundPredicate<TriggerId>": {
     "Enum": [
       {
         "tag": "Atom",
         "discriminant": 0,
-        "type": "TriggerPredicateBox"
+        "type": "TriggerIdProjection<PredicateMarker>"
       },
       {
         "tag": "Not",
         "discriminant": 1,
-        "type": "CompoundPredicate<TriggerPredicateBox>"
+        "type": "CompoundPredicate<TriggerId>"
       },
       {
         "tag": "And",
         "discriminant": 2,
-        "type": "Vec<CompoundPredicate<TriggerPredicateBox>>"
+        "type": "Vec<CompoundPredicate<TriggerId>>"
       },
       {
         "tag": "Or",
         "discriminant": 3,
-        "type": "Vec<CompoundPredicate<TriggerPredicateBox>>"
+        "type": "Vec<CompoundPredicate<TriggerId>>"
       }
     ]
   },
@@ -1603,17 +1854,40 @@
       }
     ]
   },
-  "DomainIdPredicateBox": {
+  "DomainIdPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
         "discriminant": 0,
         "type": "DomainId"
+      }
+    ]
+  },
+  "DomainIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "DomainIdPredicateAtom"
       },
       {
         "tag": "Name",
         "discriminant": 1,
-        "type": "StringPredicateBox"
+        "type": "NameProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "DomainIdProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Name",
+        "discriminant": 1,
+        "type": "NameProjection<SelectorMarker>"
       }
     ]
   },
@@ -1629,17 +1903,44 @@
       }
     ]
   },
-  "DomainPredicateBox": {
+  "DomainPredicateAtom": {
+    "Enum": []
+  },
+  "DomainProjection<PredicateMarker>": {
     "Enum": [
       {
-        "tag": "Id",
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "DomainIdPredicateBox"
+        "type": "DomainPredicateAtom"
+      },
+      {
+        "tag": "Id",
+        "discriminant": 1,
+        "type": "DomainIdProjection<PredicateMarker>"
       },
       {
         "tag": "Metadata",
+        "discriminant": 2,
+        "type": "MetadataProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "DomainProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Id",
         "discriminant": 1,
-        "type": "MetadataPredicateBox"
+        "type": "DomainIdProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Metadata",
+        "discriminant": 2,
+        "type": "MetadataProjection<SelectorMarker>"
       }
     ]
   },
@@ -2549,9 +2850,27 @@
       }
     ]
   },
-  "MetadataPredicateBox": {
+  "MetadataPredicateAtom": {
     "Enum": []
   },
+  "MetadataProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "MetadataPredicateAtom"
+      }
+    ]
+  },
+  "MetadataProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "Mint<Numeric, Asset>": {
     "Struct": [
       {
@@ -2694,6 +3013,24 @@
     ]
   },
   "Name": "String",
+  "NameProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "StringPredicateAtom"
+      }
+    ]
+  },
+  "NameProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "NewAccount": {
     "Struct": [
       {
@@ -2994,9 +3331,37 @@
       }
     ]
   },
-  "PeerPredicateBox": {
+  "PeerIdPredicateAtom": {
     "Enum": []
   },
+  "PeerIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "PeerIdPredicateAtom"
+      },
+      {
+        "tag": "PublicKey",
+        "discriminant": 1,
+        "type": "PublicKeyProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "PeerIdProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "PublicKey",
+        "discriminant": 1,
+        "type": "PublicKeyProjection<SelectorMarker>"
+      }
+    ]
+  },
   "Permission": {
     "Struct": [
       {
@@ -3009,9 +3374,27 @@
       }
     ]
   },
-  "PermissionPredicateBox": {
+  "PermissionPredicateAtom": {
     "Enum": []
   },
+  "PermissionProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "PermissionPredicateAtom"
+      }
+    ]
+  },
+  "PermissionProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "PipelineEventBox": {
     "Enum": [
       {
@@ -3052,7 +3435,7 @@
       }
     ]
   },
-  "PublicKeyPredicateBox": {
+  "PublicKeyPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
@@ -3061,82 +3444,100 @@
       }
     ]
   },
+  "PublicKeyProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "PublicKeyPredicateAtom"
+      }
+    ]
+  },
+  "PublicKeyProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "QueryBox": {
     "Enum": [
       {
         "tag": "FindDomains",
         "discriminant": 0,
-        "type": "QueryWithFilter<FindDomains, DomainPredicateBox>"
+        "type": "QueryWithFilter<FindDomains>"
       },
       {
         "tag": "FindAccounts",
         "discriminant": 1,
-        "type": "QueryWithFilter<FindAccounts, AccountPredicateBox>"
+        "type": "QueryWithFilter<FindAccounts>"
       },
       {
         "tag": "FindAssets",
         "discriminant": 2,
-        "type": "QueryWithFilter<FindAssets, AssetPredicateBox>"
+        "type": "QueryWithFilter<FindAssets>"
       },
       {
         "tag": "FindAssetsDefinitions",
         "discriminant": 3,
-        "type": "QueryWithFilter<FindAssetsDefinitions, AssetDefinitionPredicateBox>"
+        "type": "QueryWithFilter<FindAssetsDefinitions>"
       },
       {
         "tag": "FindRoles",
         "discriminant": 4,
-        "type": "QueryWithFilter<FindRoles, RolePredicateBox>"
+        "type": "QueryWithFilter<FindRoles>"
       },
       {
         "tag": "FindRoleIds",
         "discriminant": 5,
-        "type": "QueryWithFilter<FindRoleIds, RoleIdPredicateBox>"
+        "type": "QueryWithFilter<FindRoleIds>"
       },
       {
         "tag": "FindPermissionsByAccountId",
         "discriminant": 6,
-        "type": "QueryWithFilter<FindPermissionsByAccountId, PermissionPredicateBox>"
+        "type": "QueryWithFilter<FindPermissionsByAccountId>"
       },
       {
         "tag": "FindRolesByAccountId",
         "discriminant": 7,
-        "type": "QueryWithFilter<FindRolesByAccountId, RoleIdPredicateBox>"
+        "type": "QueryWithFilter<FindRolesByAccountId>"
       },
       {
         "tag": "FindAccountsWithAsset",
         "discriminant": 8,
-        "type": "QueryWithFilter<FindAccountsWithAsset, AccountPredicateBox>"
+        "type": "QueryWithFilter<FindAccountsWithAsset>"
       },
       {
         "tag": "FindPeers",
         "discriminant": 9,
-        "type": "QueryWithFilter<FindPeers, PeerPredicateBox>"
+        "type": "QueryWithFilter<FindPeers>"
       },
       {
         "tag": "FindActiveTriggerIds",
         "discriminant": 10,
-        "type": "QueryWithFilter<FindActiveTriggerIds, TriggerIdPredicateBox>"
+        "type": "QueryWithFilter<FindActiveTriggerIds>"
       },
       {
         "tag": "FindTriggers",
         "discriminant": 11,
-        "type": "QueryWithFilter<FindTriggers, TriggerPredicateBox>"
+        "type": "QueryWithFilter<FindTriggers>"
       },
       {
         "tag": "FindTransactions",
         "discriminant": 12,
-        "type": "QueryWithFilter<FindTransactions, CommittedTransactionPredicateBox>"
+        "type": "QueryWithFilter<FindTransactions>"
       },
       {
         "tag": "FindBlocks",
         "discriminant": 13,
-        "type": "QueryWithFilter<FindBlocks, SignedBlockPredicateBox>"
+        "type": "QueryWithFilter<FindBlocks>"
       },
       {
         "tag": "FindBlockHeaders",
         "discriminant": 14,
-        "type": "QueryWithFilter<FindBlockHeaders, BlockHeaderPredicateBox>"
+        "type": "QueryWithFilter<FindBlockHeaders>"
       }
     ]
   },
@@ -3182,89 +3583,162 @@
     "Struct": [
       {
         "name": "batch",
-        "type": "QueryOutputBatchBox"
+        "type": "QueryOutputBatchBoxTuple"
       },
       {
         "name": "remaining_items",
         "type": "u64"
       },
       {
-        "name": "continue_cursor",
-        "type": "Option<ForwardCursor>"
-      }
-    ]
-  },
-  "QueryOutputBatchBox": {
-    "Enum": [
+        "name": "continue_cursor",
+        "type": "Option<ForwardCursor>"
+      }
+    ]
+  },
+  "QueryOutputBatchBox": {
+    "Enum": [
+      {
+        "tag": "PublicKey",
+        "discriminant": 0,
+        "type": "Vec<PublicKey>"
+      },
+      {
+        "tag": "String",
+        "discriminant": 1,
+        "type": "Vec<String>"
+      },
+      {
+        "tag": "Metadata",
+        "discriminant": 2,
+        "type": "Vec<Metadata>"
+      },
+      {
+        "tag": "Name",
+        "discriminant": 3,
+        "type": "Vec<Name>"
+      },
+      {
+        "tag": "DomainId",
+        "discriminant": 4,
+        "type": "Vec<DomainId>"
+      },
       {
         "tag": "Domain",
-        "discriminant": 0,
+        "discriminant": 5,
         "type": "Vec<Domain>"
       },
+      {
+        "tag": "AccountId",
+        "discriminant": 6,
+        "type": "Vec<AccountId>"
+      },
       {
         "tag": "Account",
-        "discriminant": 1,
+        "discriminant": 7,
         "type": "Vec<Account>"
       },
+      {
+        "tag": "AssetId",
+        "discriminant": 8,
+        "type": "Vec<AssetId>"
+      },
       {
         "tag": "Asset",
-        "discriminant": 2,
+        "discriminant": 9,
         "type": "Vec<Asset>"
       },
+      {
+        "tag": "AssetValue",
+        "discriminant": 10,
+        "type": "Vec<AssetValue>"
+      },
+      {
+        "tag": "AssetDefinitionId",
+        "discriminant": 11,
+        "type": "Vec<AssetDefinitionId>"
+      },
       {
         "tag": "AssetDefinition",
-        "discriminant": 3,
+        "discriminant": 12,
         "type": "Vec<AssetDefinition>"
       },
       {
         "tag": "Role",
-        "discriminant": 4,
+        "discriminant": 13,
         "type": "Vec<Role>"
       },
       {
         "tag": "Parameter",
-        "discriminant": 5,
+        "discriminant": 14,
         "type": "Vec<Parameter>"
       },
       {
         "tag": "Permission",
-        "discriminant": 6,
+        "discriminant": 15,
         "type": "Vec<Permission>"
       },
       {
-        "tag": "Transaction",
-        "discriminant": 7,
+        "tag": "CommittedTransaction",
+        "discriminant": 16,
         "type": "Vec<CommittedTransaction>"
       },
+      {
+        "tag": "SignedTransaction",
+        "discriminant": 17,
+        "type": "Vec<SignedTransaction>"
+      },
+      {
+        "tag": "TransactionHash",
+        "discriminant": 18,
+        "type": "Vec<HashOf<SignedTransaction>>"
+      },
+      {
+        "tag": "TransactionRejectionReason",
+        "discriminant": 19,
+        "type": "Vec<Option<TransactionRejectionReason>>"
+      },
       {
         "tag": "Peer",
-        "discriminant": 8,
+        "discriminant": 20,
         "type": "Vec<PeerId>"
       },
       {
         "tag": "RoleId",
-        "discriminant": 9,
+        "discriminant": 21,
         "type": "Vec<RoleId>"
       },
       {
         "tag": "TriggerId",
-        "discriminant": 10,
+        "discriminant": 22,
         "type": "Vec<TriggerId>"
       },
       {
         "tag": "Trigger",
-        "discriminant": 11,
+        "discriminant": 23,
         "type": "Vec<Trigger>"
       },
       {
         "tag": "Block",
-        "discriminant": 12,
+        "discriminant": 24,
         "type": "Vec<SignedBlock>"
       },
       {
         "tag": "BlockHeader",
-        "discriminant": 13,
+        "discriminant": 25,
         "type": "Vec<BlockHeader>"
+      },
+      {
+        "tag": "BlockHeaderHash",
+        "discriminant": 26,
+        "type": "Vec<HashOf<BlockHeader>>"
+      }
+    ]
+  },
+  "QueryOutputBatchBoxTuple": {
+    "Struct": [
+      {
+        "name": "tuple",
+        "type": "Vec<QueryOutputBatchBox>"
       }
     ]
   },
@@ -3330,7 +3804,7 @@
     ]
   },
   "QuerySignature": "SignatureOf<QueryRequestWithAuthority>",
-  "QueryWithFilter<FindAccounts, AccountPredicateBox>": {
+  "QueryWithFilter<FindAccounts>": {
     "Struct": [
       {
         "name": "query",
@@ -3338,11 +3812,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<AccountPredicateBox>"
+        "type": "CompoundPredicate<Account>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Account>"
       }
     ]
   },
-  "QueryWithFilter<FindAccountsWithAsset, AccountPredicateBox>": {
+  "QueryWithFilter<FindAccountsWithAsset>": {
     "Struct": [
       {
         "name": "query",
@@ -3350,11 +3828,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<AccountPredicateBox>"
+        "type": "CompoundPredicate<Account>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Account>"
       }
     ]
   },
-  "QueryWithFilter<FindActiveTriggerIds, TriggerIdPredicateBox>": {
+  "QueryWithFilter<FindActiveTriggerIds>": {
     "Struct": [
       {
         "name": "query",
@@ -3362,11 +3844,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<TriggerIdPredicateBox>"
+        "type": "CompoundPredicate<TriggerId>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<TriggerId>"
       }
     ]
   },
-  "QueryWithFilter<FindAssets, AssetPredicateBox>": {
+  "QueryWithFilter<FindAssets>": {
     "Struct": [
       {
         "name": "query",
@@ -3374,11 +3860,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<AssetPredicateBox>"
+        "type": "CompoundPredicate<Asset>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Asset>"
       }
     ]
   },
-  "QueryWithFilter<FindAssetsDefinitions, AssetDefinitionPredicateBox>": {
+  "QueryWithFilter<FindAssetsDefinitions>": {
     "Struct": [
       {
         "name": "query",
@@ -3386,11 +3876,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<AssetDefinitionPredicateBox>"
+        "type": "CompoundPredicate<AssetDefinition>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<AssetDefinition>"
       }
     ]
   },
-  "QueryWithFilter<FindBlockHeaders, BlockHeaderPredicateBox>": {
+  "QueryWithFilter<FindBlockHeaders>": {
     "Struct": [
       {
         "name": "query",
@@ -3398,11 +3892,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<BlockHeaderPredicateBox>"
+        "type": "CompoundPredicate<BlockHeader>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<BlockHeader>"
       }
     ]
   },
-  "QueryWithFilter<FindBlocks, SignedBlockPredicateBox>": {
+  "QueryWithFilter<FindBlocks>": {
     "Struct": [
       {
         "name": "query",
@@ -3410,11 +3908,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<SignedBlockPredicateBox>"
+        "type": "CompoundPredicate<SignedBlock>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<SignedBlock>"
       }
     ]
   },
-  "QueryWithFilter<FindDomains, DomainPredicateBox>": {
+  "QueryWithFilter<FindDomains>": {
     "Struct": [
       {
         "name": "query",
@@ -3422,11 +3924,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<DomainPredicateBox>"
+        "type": "CompoundPredicate<Domain>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Domain>"
       }
     ]
   },
-  "QueryWithFilter<FindPeers, PeerPredicateBox>": {
+  "QueryWithFilter<FindPeers>": {
     "Struct": [
       {
         "name": "query",
@@ -3434,11 +3940,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<PeerPredicateBox>"
+        "type": "CompoundPredicate<PeerId>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<PeerId>"
       }
     ]
   },
-  "QueryWithFilter<FindPermissionsByAccountId, PermissionPredicateBox>": {
+  "QueryWithFilter<FindPermissionsByAccountId>": {
     "Struct": [
       {
         "name": "query",
@@ -3446,11 +3956,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<PermissionPredicateBox>"
+        "type": "CompoundPredicate<Permission>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Permission>"
       }
     ]
   },
-  "QueryWithFilter<FindRoleIds, RoleIdPredicateBox>": {
+  "QueryWithFilter<FindRoleIds>": {
     "Struct": [
       {
         "name": "query",
@@ -3458,11 +3972,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<RoleIdPredicateBox>"
+        "type": "CompoundPredicate<RoleId>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<RoleId>"
       }
     ]
   },
-  "QueryWithFilter<FindRoles, RolePredicateBox>": {
+  "QueryWithFilter<FindRoles>": {
     "Struct": [
       {
         "name": "query",
@@ -3470,11 +3988,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<RolePredicateBox>"
+        "type": "CompoundPredicate<Role>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Role>"
       }
     ]
   },
-  "QueryWithFilter<FindRolesByAccountId, RoleIdPredicateBox>": {
+  "QueryWithFilter<FindRolesByAccountId>": {
     "Struct": [
       {
         "name": "query",
@@ -3482,11 +4004,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<RoleIdPredicateBox>"
+        "type": "CompoundPredicate<RoleId>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<RoleId>"
       }
     ]
   },
-  "QueryWithFilter<FindTransactions, CommittedTransactionPredicateBox>": {
+  "QueryWithFilter<FindTransactions>": {
     "Struct": [
       {
         "name": "query",
@@ -3494,11 +4020,15 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<CommittedTransactionPredicateBox>"
+        "type": "CompoundPredicate<CommittedTransaction>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<CommittedTransaction>"
       }
     ]
   },
-  "QueryWithFilter<FindTriggers, TriggerPredicateBox>": {
+  "QueryWithFilter<FindTriggers>": {
     "Struct": [
       {
         "name": "query",
@@ -3506,7 +4036,11 @@
       },
       {
         "name": "predicate",
-        "type": "CompoundPredicate<TriggerPredicateBox>"
+        "type": "CompoundPredicate<Trigger>"
+      },
+      {
+        "name": "selector",
+        "type": "SelectorTuple<Trigger>"
       }
     ]
   },
@@ -3897,17 +4431,40 @@
       }
     ]
   },
-  "RoleIdPredicateBox": {
+  "RoleIdPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
         "discriminant": 0,
         "type": "RoleId"
+      }
+    ]
+  },
+  "RoleIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "RoleIdPredicateAtom"
+      },
+      {
+        "tag": "Name",
+        "discriminant": 1,
+        "type": "NameProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "RoleIdProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
       },
       {
         "tag": "Name",
         "discriminant": 1,
-        "type": "StringPredicateBox"
+        "type": "NameProjection<SelectorMarker>"
       }
     ]
   },
@@ -3923,12 +4480,34 @@
       }
     ]
   },
-  "RolePredicateBox": {
+  "RolePredicateAtom": {
+    "Enum": []
+  },
+  "RoleProjection<PredicateMarker>": {
     "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "RolePredicateAtom"
+      },
       {
         "tag": "Id",
+        "discriminant": 1,
+        "type": "RoleIdProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "RoleProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "RoleIdPredicateBox"
+        "type": "()"
+      },
+      {
+        "tag": "Id",
+        "discriminant": 1,
+        "type": "RoleIdProjection<SelectorMarker>"
       }
     ]
   },
@@ -3944,6 +4523,19 @@
       }
     ]
   },
+  "SelectorTuple<Account>": "Vec<AccountProjection<SelectorMarker>>",
+  "SelectorTuple<Asset>": "Vec<AssetProjection<SelectorMarker>>",
+  "SelectorTuple<AssetDefinition>": "Vec<AssetDefinitionProjection<SelectorMarker>>",
+  "SelectorTuple<BlockHeader>": "Vec<BlockHeaderProjection<SelectorMarker>>",
+  "SelectorTuple<CommittedTransaction>": "Vec<CommittedTransactionProjection<SelectorMarker>>",
+  "SelectorTuple<Domain>": "Vec<DomainProjection<SelectorMarker>>",
+  "SelectorTuple<PeerId>": "Vec<PeerIdProjection<SelectorMarker>>",
+  "SelectorTuple<Permission>": "Vec<PermissionProjection<SelectorMarker>>",
+  "SelectorTuple<Role>": "Vec<RoleProjection<SelectorMarker>>",
+  "SelectorTuple<RoleId>": "Vec<RoleIdProjection<SelectorMarker>>",
+  "SelectorTuple<SignedBlock>": "Vec<SignedBlockProjection<SelectorMarker>>",
+  "SelectorTuple<Trigger>": "Vec<TriggerProjection<SelectorMarker>>",
+  "SelectorTuple<TriggerId>": "Vec<TriggerIdProjection<SelectorMarker>>",
   "SetKeyValue<Account>": {
     "Struct": [
       {
@@ -4074,12 +4666,34 @@
       }
     ]
   },
-  "SignedBlockPredicateBox": {
+  "SignedBlockPredicateAtom": {
+    "Enum": []
+  },
+  "SignedBlockProjection<PredicateMarker>": {
     "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "SignedBlockPredicateAtom"
+      },
       {
         "tag": "Header",
+        "discriminant": 1,
+        "type": "BlockHeaderProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "SignedBlockProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "BlockHeaderPredicateBox"
+        "type": "()"
+      },
+      {
+        "tag": "Header",
+        "discriminant": 1,
+        "type": "BlockHeaderProjection<SelectorMarker>"
       }
     ]
   },
@@ -4129,17 +4743,44 @@
       }
     ]
   },
-  "SignedTransactionPredicateBox": {
+  "SignedTransactionPredicateAtom": {
+    "Enum": []
+  },
+  "SignedTransactionProjection<PredicateMarker>": {
     "Enum": [
       {
-        "tag": "Hash",
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "TransactionHashPredicateBox"
+        "type": "SignedTransactionPredicateAtom"
+      },
+      {
+        "tag": "Hash",
+        "discriminant": 1,
+        "type": "TransactionHashProjection<PredicateMarker>"
       },
       {
         "tag": "Authority",
+        "discriminant": 2,
+        "type": "AccountIdProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "SignedTransactionProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      },
+      {
+        "tag": "Hash",
         "discriminant": 1,
-        "type": "AccountIdPredicateBox"
+        "type": "TransactionHashProjection<SelectorMarker>"
+      },
+      {
+        "tag": "Authority",
+        "discriminant": 2,
+        "type": "AccountIdProjection<SelectorMarker>"
       }
     ]
   },
@@ -4358,7 +4999,7 @@
     ]
   },
   "String": "String",
-  "StringPredicateBox": {
+  "StringPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
@@ -4438,7 +5079,7 @@
       }
     ]
   },
-  "TransactionErrorPredicateBox": {
+  "TransactionErrorPredicateAtom": {
     "Enum": [
       {
         "tag": "IsSome",
@@ -4446,6 +5087,24 @@
       }
     ]
   },
+  "TransactionErrorProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "TransactionErrorPredicateAtom"
+      }
+    ]
+  },
+  "TransactionErrorProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "TransactionEvent": {
     "Struct": [
       {
@@ -4478,7 +5137,7 @@
       }
     ]
   },
-  "TransactionHashPredicateBox": {
+  "TransactionHashPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
@@ -4487,6 +5146,24 @@
       }
     ]
   },
+  "TransactionHashProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "TransactionHashPredicateAtom"
+      }
+    ]
+  },
+  "TransactionHashProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
+      }
+    ]
+  },
   "TransactionLimitError": {
     "Struct": [
       {
@@ -4833,17 +5510,40 @@
       }
     ]
   },
-  "TriggerIdPredicateBox": {
+  "TriggerIdPredicateAtom": {
     "Enum": [
       {
         "tag": "Equals",
         "discriminant": 0,
         "type": "TriggerId"
+      }
+    ]
+  },
+  "TriggerIdProjection<PredicateMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "TriggerIdPredicateAtom"
+      },
+      {
+        "tag": "Name",
+        "discriminant": 1,
+        "type": "NameProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "TriggerIdProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "()"
       },
       {
         "tag": "Name",
         "discriminant": 1,
-        "type": "StringPredicateBox"
+        "type": "NameProjection<SelectorMarker>"
       }
     ]
   },
@@ -4859,12 +5559,34 @@
       }
     ]
   },
-  "TriggerPredicateBox": {
+  "TriggerPredicateAtom": {
+    "Enum": []
+  },
+  "TriggerProjection<PredicateMarker>": {
     "Enum": [
+      {
+        "tag": "Atom",
+        "discriminant": 0,
+        "type": "TriggerPredicateAtom"
+      },
       {
         "tag": "Id",
+        "discriminant": 1,
+        "type": "TriggerIdProjection<PredicateMarker>"
+      }
+    ]
+  },
+  "TriggerProjection<SelectorMarker>": {
+    "Enum": [
+      {
+        "tag": "Atom",
         "discriminant": 0,
-        "type": "TriggerIdPredicateBox"
+        "type": "()"
+      },
+      {
+        "tag": "Id",
+        "discriminant": 1,
+        "type": "TriggerIdProjection<SelectorMarker>"
       }
     ]
   },
@@ -5015,99 +5737,177 @@
   "Vec<Account>": {
     "Vec": "Account"
   },
+  "Vec<AccountId>": {
+    "Vec": "AccountId"
+  },
+  "Vec<AccountProjection<SelectorMarker>>": {
+    "Vec": "AccountProjection<SelectorMarker>"
+  },
   "Vec<Asset>": {
     "Vec": "Asset"
   },
   "Vec<AssetDefinition>": {
     "Vec": "AssetDefinition"
   },
+  "Vec<AssetDefinitionId>": {
+    "Vec": "AssetDefinitionId"
+  },
+  "Vec<AssetDefinitionProjection<SelectorMarker>>": {
+    "Vec": "AssetDefinitionProjection<SelectorMarker>"
+  },
+  "Vec<AssetId>": {
+    "Vec": "AssetId"
+  },
+  "Vec<AssetProjection<SelectorMarker>>": {
+    "Vec": "AssetProjection<SelectorMarker>"
+  },
+  "Vec<AssetValue>": {
+    "Vec": "AssetValue"
+  },
   "Vec<BlockHeader>": {
     "Vec": "BlockHeader"
   },
+  "Vec<BlockHeaderProjection<SelectorMarker>>": {
+    "Vec": "BlockHeaderProjection<SelectorMarker>"
+  },
   "Vec<BlockSignature>": {
     "Vec": "BlockSignature"
   },
   "Vec<CommittedTransaction>": {
     "Vec": "CommittedTransaction"
   },
-  "Vec<CompoundPredicate<AccountPredicateBox>>": {
-    "Vec": "CompoundPredicate<AccountPredicateBox>"
+  "Vec<CommittedTransactionProjection<SelectorMarker>>": {
+    "Vec": "CommittedTransactionProjection<SelectorMarker>"
   },
-  "Vec<CompoundPredicate<AssetDefinitionPredicateBox>>": {
-    "Vec": "CompoundPredicate<AssetDefinitionPredicateBox>"
+  "Vec<CompoundPredicate<Account>>": {
+    "Vec": "CompoundPredicate<Account>"
   },
-  "Vec<CompoundPredicate<AssetPredicateBox>>": {
-    "Vec": "CompoundPredicate<AssetPredicateBox>"
+  "Vec<CompoundPredicate<Asset>>": {
+    "Vec": "CompoundPredicate<Asset>"
   },
-  "Vec<CompoundPredicate<BlockHeaderPredicateBox>>": {
-    "Vec": "CompoundPredicate<BlockHeaderPredicateBox>"
+  "Vec<CompoundPredicate<AssetDefinition>>": {
+    "Vec": "CompoundPredicate<AssetDefinition>"
   },
-  "Vec<CompoundPredicate<CommittedTransactionPredicateBox>>": {
-    "Vec": "CompoundPredicate<CommittedTransactionPredicateBox>"
+  "Vec<CompoundPredicate<BlockHeader>>": {
+    "Vec": "CompoundPredicate<BlockHeader>"
   },
-  "Vec<CompoundPredicate<DomainPredicateBox>>": {
-    "Vec": "CompoundPredicate<DomainPredicateBox>"
+  "Vec<CompoundPredicate<CommittedTransaction>>": {
+    "Vec": "CompoundPredicate<CommittedTransaction>"
   },
-  "Vec<CompoundPredicate<PeerPredicateBox>>": {
-    "Vec": "CompoundPredicate<PeerPredicateBox>"
+  "Vec<CompoundPredicate<Domain>>": {
+    "Vec": "CompoundPredicate<Domain>"
   },
-  "Vec<CompoundPredicate<PermissionPredicateBox>>": {
-    "Vec": "CompoundPredicate<PermissionPredicateBox>"
+  "Vec<CompoundPredicate<PeerId>>": {
+    "Vec": "CompoundPredicate<PeerId>"
   },
-  "Vec<CompoundPredicate<RoleIdPredicateBox>>": {
-    "Vec": "CompoundPredicate<RoleIdPredicateBox>"
+  "Vec<CompoundPredicate<Permission>>": {
+    "Vec": "CompoundPredicate<Permission>"
   },
-  "Vec<CompoundPredicate<RolePredicateBox>>": {
-    "Vec": "CompoundPredicate<RolePredicateBox>"
+  "Vec<CompoundPredicate<Role>>": {
+    "Vec": "CompoundPredicate<Role>"
   },
-  "Vec<CompoundPredicate<SignedBlockPredicateBox>>": {
-    "Vec": "CompoundPredicate<SignedBlockPredicateBox>"
+  "Vec<CompoundPredicate<RoleId>>": {
+    "Vec": "CompoundPredicate<RoleId>"
   },
-  "Vec<CompoundPredicate<TriggerIdPredicateBox>>": {
-    "Vec": "CompoundPredicate<TriggerIdPredicateBox>"
+  "Vec<CompoundPredicate<SignedBlock>>": {
+    "Vec": "CompoundPredicate<SignedBlock>"
   },
-  "Vec<CompoundPredicate<TriggerPredicateBox>>": {
-    "Vec": "CompoundPredicate<TriggerPredicateBox>"
+  "Vec<CompoundPredicate<Trigger>>": {
+    "Vec": "CompoundPredicate<Trigger>"
+  },
+  "Vec<CompoundPredicate<TriggerId>>": {
+    "Vec": "CompoundPredicate<TriggerId>"
   },
   "Vec<Domain>": {
     "Vec": "Domain"
   },
+  "Vec<DomainId>": {
+    "Vec": "DomainId"
+  },
+  "Vec<DomainProjection<SelectorMarker>>": {
+    "Vec": "DomainProjection<SelectorMarker>"
+  },
   "Vec<EventFilterBox>": {
     "Vec": "EventFilterBox"
   },
   "Vec<GenesisWasmTrigger>": {
     "Vec": "GenesisWasmTrigger"
   },
+  "Vec<HashOf<BlockHeader>>": {
+    "Vec": "HashOf<BlockHeader>"
+  },
+  "Vec<HashOf<SignedTransaction>>": {
+    "Vec": "HashOf<SignedTransaction>"
+  },
   "Vec<InstructionBox>": {
     "Vec": "InstructionBox"
   },
+  "Vec<Metadata>": {
+    "Vec": "Metadata"
+  },
+  "Vec<Name>": {
+    "Vec": "Name"
+  },
+  "Vec<Option<TransactionRejectionReason>>": {
+    "Vec": "Option<TransactionRejectionReason>"
+  },
   "Vec<Parameter>": {
     "Vec": "Parameter"
   },
   "Vec<PeerId>": {
     "Vec": "PeerId"
   },
+  "Vec<PeerIdProjection<SelectorMarker>>": {
+    "Vec": "PeerIdProjection<SelectorMarker>"
+  },
   "Vec<Permission>": {
     "Vec": "Permission"
   },
+  "Vec<PermissionProjection<SelectorMarker>>": {
+    "Vec": "PermissionProjection<SelectorMarker>"
+  },
+  "Vec<PublicKey>": {
+    "Vec": "PublicKey"
+  },
+  "Vec<QueryOutputBatchBox>": {
+    "Vec": "QueryOutputBatchBox"
+  },
   "Vec<Role>": {
     "Vec": "Role"
   },
   "Vec<RoleId>": {
     "Vec": "RoleId"
   },
+  "Vec<RoleIdProjection<SelectorMarker>>": {
+    "Vec": "RoleIdProjection<SelectorMarker>"
+  },
+  "Vec<RoleProjection<SelectorMarker>>": {
+    "Vec": "RoleProjection<SelectorMarker>"
+  },
   "Vec<SignedBlock>": {
     "Vec": "SignedBlock"
   },
+  "Vec<SignedBlockProjection<SelectorMarker>>": {
+    "Vec": "SignedBlockProjection<SelectorMarker>"
+  },
   "Vec<SignedTransaction>": {
     "Vec": "SignedTransaction"
   },
+  "Vec<String>": {
+    "Vec": "String"
+  },
   "Vec<Trigger>": {
     "Vec": "Trigger"
   },
   "Vec<TriggerId>": {
     "Vec": "TriggerId"
   },
+  "Vec<TriggerIdProjection<SelectorMarker>>": {
+    "Vec": "TriggerIdProjection<SelectorMarker>"
+  },
+  "Vec<TriggerProjection<SelectorMarker>>": {
+    "Vec": "TriggerProjection<SelectorMarker>"
+  },
   "Vec<u8>": {
     "Vec": "u8"
   },
diff --git a/pytests/iroha_cli_tests/src/iroha_cli/have.py b/pytests/iroha_cli_tests/src/iroha_cli/have.py
index a27db42c0dd..62359660a59 100644
--- a/pytests/iroha_cli_tests/src/iroha_cli/have.py
+++ b/pytests/iroha_cli_tests/src/iroha_cli/have.py
@@ -44,7 +44,9 @@ def domain(expected: Any, owned_by: Optional[Any] = None) -> bool:
     """
 
     def domain_in_domains() -> bool:
-        domains = iroha.list_filter({"Atom": {"Id": {"Equals": expected}}}).domains()
+        domains = iroha.list_filter(
+            {"Atom": {"Id": {"Atom": {"Equals": expected}}}}
+        ).domains()
         if not expected_in_actual(expected, domains):
             return False
         if owned_by:
@@ -65,7 +67,9 @@ def account(expected: Any) -> bool:
     """
 
     def account_in_accounts() -> bool:
-        accounts = iroha.list_filter({"Atom": {"Id": {"Equals": expected}}}).accounts()
+        accounts = iroha.list_filter(
+            {"Atom": {"Id": {"Atom": {"Equals": expected}}}}
+        ).accounts()
         return expected_in_actual(expected, accounts)
 
     return iroha_cli.wait_for(account_in_accounts)
@@ -81,7 +85,7 @@ def asset_definition(expected: Any) -> bool:
 
     def asset_definition_in_asset_definitions() -> bool:
         asset_definitions = iroha.list_filter(
-            {"Atom": {"Id": {"Equals": expected}}}
+            {"Atom": {"Id": {"Atom": {"Equals": expected}}}}
         ).asset_definitions()
         return expected_in_actual(expected, asset_definitions)
 
@@ -97,7 +101,9 @@ def asset(expected: Any) -> bool:
     """
 
     def asset_in_assets() -> bool:
-        assets = iroha.list_filter({"Atom": {"Id": {"Equals": expected}}}).assets()
+        assets = iroha.list_filter(
+            {"Atom": {"Id": {"Atom": {"Equals": expected}}}}
+        ).assets()
         return expected_in_actual(expected, assets)
 
     return iroha_cli.wait_for(asset_in_assets)
@@ -114,7 +120,7 @@ def asset_has_quantity(expected_asset_id: Any, expected_quantity: str) -> bool:
 
     def check_quantity() -> bool:
         assets = iroha.list_filter(
-            {"Atom": {"Id": {"Equals": expected_asset_id}}}
+            {"Atom": {"Id": {"Atom": {"Equals": expected_asset_id}}}}
         ).assets()
         actual_quantity = None
         for asset_item in assets:
diff --git a/pytests/iroha_cli_tests/test/accounts/test_accounts_query_filters.py b/pytests/iroha_cli_tests/test/accounts/test_accounts_query_filters.py
index fa14dff4918..25695639843 100644
--- a/pytests/iroha_cli_tests/test/accounts/test_accounts_query_filters.py
+++ b/pytests/iroha_cli_tests/test/accounts/test_accounts_query_filters.py
@@ -11,7 +11,7 @@ def condition():
         domain = GIVEN_registered_account.domain
         with allure.step(f"WHEN iroha_cli query accounts " f'in the "{domain}" domain'):
             accounts = iroha.list_filter(
-                {"Atom": {"Id": {"DomainId": {"Equals": domain}}}}
+                {"Atom": {"Id": {"Domain": {"Atom": {"Equals": domain}}}}}
             ).accounts()
         with allure.step("THEN Iroha should return only accounts with this domain"):
             allure.attach(
@@ -33,7 +33,7 @@ def condition():
             f'WHEN iroha_cli query accounts with account id "{account_id}"'
         ):
             accounts = iroha.list_filter(
-                {"Atom": {"Id": {"Equals": account_id}}}
+                {"Atom": {"Id": {"Atom": {"Equals": account_id}}}}
             ).accounts()
         with allure.step("THEN Iroha should return only accounts with this id"):
             allure.attach(
diff --git a/pytests/iroha_cli_tests/test/assets/test_assets_query_filters.py b/pytests/iroha_cli_tests/test/assets/test_assets_query_filters.py
index 8f6dc5ecd0d..4c473964fc0 100644
--- a/pytests/iroha_cli_tests/test/assets/test_assets_query_filters.py
+++ b/pytests/iroha_cli_tests/test/assets/test_assets_query_filters.py
@@ -13,7 +13,11 @@ def condition():
         )
         with allure.step(f"WHEN iroha_cli query assets" f'in the "{domain}" domain'):
             assets = iroha.list_filter(
-                {"Atom": {"Id": {"DefinitionId": {"DomainId": {"Equals": domain}}}}}
+                {
+                    "Atom": {
+                        "Id": {"Definition": {"Domain": {"Atom": {"Equals": domain}}}}
+                    }
+                }
             ).assets()
         with allure.step("THEN Iroha should return only assets with this domain"):
             allure.attach(
@@ -38,7 +42,7 @@ def condition():
         )
         with allure.step(f'WHEN iroha_cli query assets with name "{name}"'):
             assets = iroha.list_filter(
-                {"Atom": {"Id": {"DefinitionId": {"Name": {"Equals": name}}}}}
+                {"Atom": {"Id": {"Definition": {"Name": {"Atom": {"Equals": name}}}}}}
             ).assets()
         with allure.step("THEN Iroha should return only assets with this name"):
             allure.attach(
@@ -64,7 +68,9 @@ def condition():
             + GIVEN_currently_authorized_account.domain
         )
         with allure.step(f'WHEN iroha_cli query assets with asset id "{asset_id}"'):
-            assets = iroha.list_filter({"Atom": {"Id": {"Equals": asset_id}}}).assets()
+            assets = iroha.list_filter(
+                {"Atom": {"Id": {"Atom": {"Equals": asset_id}}}}
+            ).assets()
         with allure.step("THEN Iroha should return only assets with this id"):
             allure.attach(
                 json.dumps(assets),
diff --git a/pytests/iroha_cli_tests/test/domains/test_domains_query_filters.py b/pytests/iroha_cli_tests/test/domains/test_domains_query_filters.py
index 4c365012825..19b5f7da07e 100644
--- a/pytests/iroha_cli_tests/test/domains/test_domains_query_filters.py
+++ b/pytests/iroha_cli_tests/test/domains/test_domains_query_filters.py
@@ -12,7 +12,7 @@ def condition():
             f'WHEN iroha_cli query domains filtered by name "{domain_name}"'
         ):
             domains = iroha.list_filter(
-                {"Atom": {"Id": {"Equals": domain_name}}}
+                {"Atom": {"Id": {"Atom": {"Equals": domain_name}}}}
             ).domains()
         with allure.step(
             f'THEN Iroha should return only return domains with "{domain_name}" name'
diff --git a/wasm/samples/query_assets_and_save_cursor/src/lib.rs b/wasm/samples/query_assets_and_save_cursor/src/lib.rs
index e7261d9b9b4..576b46e9948 100644
--- a/wasm/samples/query_assets_and_save_cursor/src/lib.rs
+++ b/wasm/samples/query_assets_and_save_cursor/src/lib.rs
@@ -9,8 +9,8 @@ use dlmalloc::GlobalDlmalloc;
 use iroha_smart_contract::{
     data_model::query::{
         builder::QueryExecutor,
+        dsl::{CompoundPredicate, SelectorTuple},
         parameters::{ForwardCursor, QueryParams},
-        predicate::CompoundPredicate,
         QueryWithFilter, QueryWithParams,
     },
     prelude::*,
@@ -32,7 +32,12 @@ fn main(host: Iroha, context: Context) {
 
     let (_batch, _remaining_items, cursor) = host
         .start_query(QueryWithParams::new(
-            QueryWithFilter::new(FindAssets, CompoundPredicate::PASS).into(),
+            QueryWithFilter::new(
+                FindAssets,
+                CompoundPredicate::PASS,
+                SelectorTuple::default(),
+            )
+            .into(),
             QueryParams::new(
                 Default::default(),
                 Default::default(),
diff --git a/wasm/samples/smart_contract_can_filter_queries/src/lib.rs b/wasm/samples/smart_contract_can_filter_queries/src/lib.rs
index 798f719629c..68b670256e1 100644
--- a/wasm/samples/smart_contract_can_filter_queries/src/lib.rs
+++ b/wasm/samples/smart_contract_can_filter_queries/src/lib.rs
@@ -41,7 +41,7 @@ fn main(host: Iroha, _context: Context) {
     // genesis registers some more asset definitions, but we apply a filter to find only the ones from the `looking_glass` domain
     let cursor = host
         .query(FindAssetsDefinitions)
-        .filter_with(|asset_definition| asset_definition.id.domain_id.eq(domain_id))
+        .filter_with(|asset_definition| asset_definition.id.domain.eq(domain_id.clone()))
         .execute()
         .dbg_unwrap();
 
@@ -52,8 +52,32 @@ fn main(host: Iroha, _context: Context) {
         asset_definition_ids.insert(asset_definition.id().clone());
     }
 
-    assert_eq!(
-        asset_definition_ids,
-        [time_id, space_id].into_iter().collect()
-    );
+    let expected_asset_definition_ids = [time_id.clone(), space_id.clone()].into_iter().collect();
+
+    assert_eq!(asset_definition_ids, expected_asset_definition_ids);
+
+    // do the same as above, but utilizing server-side projections
+    let asset_definition_ids = host
+        .query(FindAssetsDefinitions)
+        .filter_with(|asset_definition| asset_definition.id.domain.eq(domain_id.clone()))
+        .select_with(|asset_definition| asset_definition.id)
+        .execute()
+        .dbg_unwrap()
+        .map(|v| v.dbg_unwrap())
+        .collect::<BTreeSet<_>>();
+
+    assert_eq!(asset_definition_ids, expected_asset_definition_ids);
+
+    // do the same as above, but passing the asset definition id as a 2-tuple
+    let asset_definition_ids = host
+        .query(FindAssetsDefinitions)
+        .filter_with(|asset_definition| asset_definition.id.domain.eq(domain_id))
+        .select_with(|asset_definition| (asset_definition.id.domain, asset_definition.id.name))
+        .execute()
+        .dbg_unwrap()
+        .map(|v| v.dbg_unwrap())
+        .map(|(domain, name)| AssetDefinitionId::new(domain, name))
+        .collect::<BTreeSet<_>>();
+
+    assert_eq!(asset_definition_ids, expected_asset_definition_ids);
 }