[refactor]: Add ExpressionEvaluator

Signed-off-by: Marin Veršić <marin.versic101@gmail.com>

client/tests/integration/smartcontracts/validator_with_admin/src/lib.rs

@@ -2,7 +2,12 @@
 //! If authority is not `admin@admin` then [`DefaultValidator`] is used as a backup.
 #![no_std]
 
-use iroha_validator::{parse, prelude::*, DefaultValidator};
+use iroha_validator::{
+    data_model::evaluate::{Error, ExpressionEvaluator},
+    parse,
+    prelude::*,
+    DefaultValidator,
+};
 
 #[cfg(not(test))]
 extern crate panic_halt;
@@ -19,11 +24,17 @@ impl Validate for Validator {
     }
 }
 
+impl ExpressionEvaluator for Validator {
+    fn evaluate<E: Evaluate>(&self, expression: &E) -> Result<E::Value, Error> {
+        self.0.evaluate(expression)
+    }
+}
+
 /// Allow operation if authority is `admin@admin` and if not,
 /// fallback to [`DefaultValidator::validate()`].
 #[entrypoint(params = "[authority, operation]")]
 pub fn validate(authority: AccountId, operation: NeedsValidationBox) -> Verdict {
-    let mut validator = Validator(DefaultValidator);
+    let mut validator = Validator(DefaultValidator::new());
 
     match operation {
         // NOTE: Invoked from Iroha

core/src/smartcontracts/isi/account.rs

@@ -4,7 +4,7 @@
 use iroha_data_model::{asset::AssetsMap, prelude::*, query::error::FindError, role::RoleIds};
 use iroha_telemetry::metrics;
 
-use super::{prelude::*, Context};
+use super::prelude::*;
 use crate::{ValidQuery, WorldStateView};
 
 impl Registrable for iroha_data_model::account::NewAccount {
@@ -473,16 +473,17 @@ pub mod isi {
 pub mod query {
 
     use eyre::{Result, WrapErr};
-    use iroha_data_model::query::error::QueryExecutionFailure as Error;
+    use iroha_data_model::{
+        evaluate::ExpressionEvaluator, query::error::QueryExecutionFailure as Error,
+    };
 
-    use super::{super::Evaluate, *};
+    use super::*;
 
     impl ValidQuery for FindRolesByAccountId {
         #[metrics(+"find_roles_by_account_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let account_id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let account_id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to evaluate account id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%account_id, roles=?wsv.world.roles);
@@ -496,9 +497,8 @@ pub mod query {
     impl ValidQuery for FindPermissionTokensByAccountId {
         #[metrics(+"find_permission_tokens_by_account_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let account_id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let account_id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to evaluate account id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%account_id, accounts=?wsv.world.domains);
@@ -525,9 +525,8 @@ pub mod query {
     impl ValidQuery for FindAccountById {
         #[metrics(+"find_account_by_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -538,9 +537,8 @@ pub mod query {
     impl ValidQuery for FindAccountsByName {
         #[metrics(+"find_account_by_name")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let name = self
-                .name
-                .evaluate(&Context::new(wsv))
+            let name = wsv
+                .evaluate(&self.name)
                 .wrap_err("Failed to get account name")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%name);
@@ -559,9 +557,8 @@ pub mod query {
     impl ValidQuery for FindAccountsByDomainId {
         #[metrics(+"find_accounts_by_domain_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .domain_id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.domain_id)
                 .wrap_err("Failed to get domain id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -572,14 +569,12 @@ pub mod query {
     impl ValidQuery for FindAccountKeyValueByIdAndKey {
         #[metrics(+"find_account_key_value_by_id_and_key")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get account id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
-            let key = self
-                .key
-                .evaluate(&Context::new(wsv))
+            let key = wsv
+                .evaluate(&self.key)
                 .wrap_err("Failed to get key")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id, %key);
@@ -591,9 +586,8 @@ pub mod query {
     impl ValidQuery for FindAccountsWithAsset {
         #[metrics(+"find_accounts_with_asset")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let asset_definition_id = self
-                .asset_definition_id
-                .evaluate(&Context::new(wsv))
+            let asset_definition_id = wsv
+                .evaluate(&self.asset_definition_id)
                 .wrap_err("Failed to get asset id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%asset_definition_id);

core/src/smartcontracts/isi/asset.rs

@@ -462,9 +462,8 @@ pub mod query {
     impl ValidQuery for FindAssetById {
         #[metrics(+"find_asset_by_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get asset id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -481,9 +480,8 @@ pub mod query {
     impl ValidQuery for FindAssetDefinitionById {
         #[metrics(+"find_asset_defintion_by_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get asset definition id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
 
@@ -496,9 +494,8 @@ pub mod query {
     impl ValidQuery for FindAssetsByName {
         #[metrics(+"find_assets_by_name")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let name = self
-                .name
-                .evaluate(&Context::new(wsv))
+            let name = wsv
+                .evaluate(&self.name)
                 .wrap_err("Failed to get asset name")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%name);
@@ -519,9 +516,8 @@ pub mod query {
     impl ValidQuery for FindAssetsByAccountId {
         #[metrics(+"find_assets_by_account_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .account_id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.account_id)
                 .wrap_err("Failed to get account id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -532,9 +528,8 @@ pub mod query {
     impl ValidQuery for FindAssetsByAssetDefinitionId {
         #[metrics(+"find_assets_by_asset_definition_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .asset_definition_id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.asset_definition_id)
                 .wrap_err("Failed to get asset definition id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -555,9 +550,8 @@ pub mod query {
     impl ValidQuery for FindAssetsByDomainId {
         #[metrics(+"find_assets_by_domain_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .domain_id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.domain_id)
                 .wrap_err("Failed to get domain id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -574,14 +568,12 @@ pub mod query {
     impl ValidQuery for FindAssetsByDomainIdAndAssetDefinitionId {
         #[metrics(+"find_assets_by_domain_id_and_asset_definition_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let domain_id = self
-                .domain_id
-                .evaluate(&Context::new(wsv))
+            let domain_id = wsv
+                .evaluate(&self.domain_id)
                 .wrap_err("Failed to get domain id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
-            let asset_definition_id = self
-                .asset_definition_id
-                .evaluate(&Context::new(wsv))
+            let asset_definition_id = wsv
+                .evaluate(&self.asset_definition_id)
                 .wrap_err("Failed to get asset definition id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             let domain = wsv.domain(&domain_id)?;
@@ -607,9 +599,8 @@ pub mod query {
     impl ValidQuery for FindAssetQuantityById {
         #[metrics(+"find_asset_quantity_by_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get asset id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -632,9 +623,8 @@ pub mod query {
     impl ValidQuery for FindTotalAssetQuantityByAssetDefinitionId {
         #[metrics(+"find_total_asset_quantity_by_asset_definition_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get asset definition id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -646,14 +636,12 @@ pub mod query {
     impl ValidQuery for FindAssetKeyValueByIdAndKey {
         #[metrics(+"find_asset_key_value_by_id_and_key")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get asset id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
-            let key = self
-                .key
-                .evaluate(&Context::new(wsv))
+            let key = wsv
+                .evaluate(&self.key)
                 .wrap_err("Failed to get key")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             let asset = wsv.asset(&id).map_err(|asset_err| {
@@ -679,14 +667,12 @@ pub mod query {
     impl ValidQuery for IsAssetDefinitionOwner {
         #[metrics("is_asset_definition_owner")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let asset_definition_id = self
-                .asset_definition_id
-                .evaluate(&Context::new(wsv))
+            let asset_definition_id = wsv
+                .evaluate(&self.asset_definition_id)
                 .wrap_err("Failed to get asset definition id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
-            let account_id = self
-                .account_id
-                .evaluate(&Context::new(wsv))
+            let account_id = wsv
+                .evaluate(&self.account_id)
                 .wrap_err("Failed to get account id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
 

core/src/smartcontracts/isi/block.rs

@@ -1,8 +1,11 @@
 //! This module contains trait implementations related to block queries
 use eyre::{Result, WrapErr};
-use iroha_data_model::query::{
-    block::FindBlockHeaderByHash,
-    error::{FindError, QueryExecutionFailure},
+use iroha_data_model::{
+    evaluate::ExpressionEvaluator,
+    query::{
+        block::FindBlockHeaderByHash,
+        error::{FindError, QueryExecutionFailure},
+    },
 };
 use iroha_telemetry::metrics;
 
@@ -31,9 +34,8 @@ impl ValidQuery for FindAllBlockHeaders {
 impl ValidQuery for FindBlockHeaderByHash {
     #[metrics(+"find_block_header")]
     fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, QueryExecutionFailure> {
-        let hash = self
-            .hash
-            .evaluate(&Context::new(wsv))
+        let hash = wsv
+            .evaluate(&self.hash)
             .wrap_err("Failed to evaluate hash")
             .map_err(|e| QueryExecutionFailure::Evaluate(e.to_string()))?
             .typed();

core/src/smartcontracts/isi/domain.rs

@@ -328,9 +328,8 @@ pub mod query {
     impl ValidQuery for FindDomainById {
         #[metrics(+"find_domain_by_id")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get domain id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id);
@@ -341,14 +340,12 @@ pub mod query {
     impl ValidQuery for FindDomainKeyValueByIdAndKey {
         #[metrics(+"find_domain_key_value_by_id_and_key")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get domain id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
-            let key = self
-                .key
-                .evaluate(&Context::new(wsv))
+            let key = wsv
+                .evaluate(&self.key)
                 .wrap_err("Failed to get key")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id, %key);
@@ -362,14 +359,12 @@ pub mod query {
     impl ValidQuery for FindAssetDefinitionKeyValueByIdAndKey {
         #[metrics(+"find_asset_definition_key_value_by_id_and_key")]
         fn execute(&self, wsv: &WorldStateView) -> Result<Self::Output, Error> {
-            let id = self
-                .id
-                .evaluate(&Context::new(wsv))
+            let id = wsv
+                .evaluate(&self.id)
                 .wrap_err("Failed to get asset definition id")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
-            let key = self
-                .key
-                .evaluate(&Context::new(wsv))
+            let key = wsv
+                .evaluate(&self.key)
                 .wrap_err("Failed to get key")
                 .map_err(|e| Error::Evaluate(e.to_string()))?;
             iroha_logger::trace!(%id, %key);