fix: fix transparent_api violations

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

Cargo.toml

@@ -67,7 +67,6 @@ parking_lot = { version = "0.12.3" }
 
 tempfile = "3.10.1"
 path-absolutize = "3.1.1"
-pathdiff = "0.2.1"
 bytes = "1.6.1"
 
 vergen = { version = "8.3.1", default-features = false }
@@ -84,7 +83,6 @@ prometheus = { version = "0.13.4", default-features = false }
 clap = "4.5.11"
 owo-colors = "4.1.0"
 supports-color = "2.1.0"
-inquire = "0.6.2"
 spinoff = "0.8.0"
 
 criterion = "0.5.1"
@@ -116,7 +114,6 @@ rustc-hash = "1.1.0"
 
 serde = { version = "1.0.204", default-features = false }
 serde_json = { version = "1.0.121", default-features = false }
-serde_yaml = "0.9.34"
 serde_with = { version = "3.9.0", default-features = false }
 parity-scale-codec = { version = "3.6.12", default-features = false }
 json5 = "0.4.1"

crates/iroha/tests/asset.rs

@@ -3,7 +3,7 @@ use iroha::{
     crypto::KeyPair,
     data_model::{
         asset::{AssetId, AssetType, AssetValue},
-        isi::error::{InstructionEvaluationError, InstructionExecutionError, Mismatch, TypeError},
+        isi::error::{InstructionEvaluationError, InstructionExecutionError, TypeError},
         prelude::*,
         transaction::error::TransactionRejectionReason,
     },
@@ -400,16 +400,21 @@ fn fail_if_dont_satisfy_spec() {
             .downcast_ref::<TransactionRejectionReason>()
             .unwrap_or_else(|| panic!("Error {err} is not TransactionRejectionReason"));
 
+        let TransactionRejectionReason::Validation(ValidationFail::InstructionFailed(
+            InstructionExecutionError::Evaluate(InstructionEvaluationError::Type(
+                TypeError::AssetType(rejection_reason),
+            )),
+        )) = rejection_reason
+        else {
+            panic!("Wrong rejection reason");
+        };
+        assert_eq!(
+            *rejection_reason.expected(),
+            AssetType::Numeric(NumericSpec::integer()),
+        );
         assert_eq!(
-            rejection_reason,
-            &TransactionRejectionReason::Validation(ValidationFail::InstructionFailed(
-                InstructionExecutionError::Evaluate(InstructionEvaluationError::Type(
-                    TypeError::from(Mismatch {
-                        expected: AssetType::Numeric(NumericSpec::integer()),
-                        actual: AssetType::Numeric(NumericSpec::fractional(2))
-                    })
-                ))
-            ))
+            *rejection_reason.actual(),
+            AssetType::Numeric(NumericSpec::fractional(2))
         );
     }
 

crates/iroha/tests/events/pipeline.rs

@@ -1,6 +1,5 @@
 use std::time::Duration;
 
-use assert_matches::assert_matches;
 use eyre::Result;
 use futures_util::StreamExt;
 use iroha::data_model::{
@@ -54,20 +53,20 @@ async fn test_with_instruction_and_status(
 
     // Then
     timeout(Duration::from_secs(5), async move {
-        assert_matches!(
-            events.next().await.unwrap().unwrap(),
-            EventBox::Pipeline(PipelineEventBox::Transaction(TransactionEvent {
-                status: TransactionStatus::Queued,
-                ..
-            }))
-        );
-        assert_matches!(
-            events.next().await.unwrap().unwrap(),
-            EventBox::Pipeline(PipelineEventBox::Transaction(TransactionEvent {
-                status,
-                ..
-            })) if status == *should_be
-        );
+        let EventBox::Pipeline(PipelineEventBox::Transaction(event)) =
+            events.next().await.unwrap().unwrap()
+        else {
+            panic!("Expected transaction event");
+        };
+        assert_eq!(*event.status(), TransactionStatus::Queued);
+
+        let EventBox::Pipeline(PipelineEventBox::Transaction(event)) =
+            events.next().await.unwrap().unwrap()
+        else {
+            panic!("Expected transaction event");
+        };
+
+        assert_eq!(event.status(), should_be);
     })
     .await?;
 

crates/iroha/tests/extra_functional/multiple_blocks_created.rs

@@ -29,7 +29,7 @@ async fn multiple_blocks_created() -> Result<()> {
     // Given
     let network = NetworkBuilder::new()
         .with_peers(4)
-        .with_genesis_instruction(SetParameter(Parameter::Block(
+        .with_genesis_instruction(SetParameter::new(Parameter::Block(
             BlockParameter::MaxTransactions(NonZero::new(N_MAX_TXS_PER_BLOCK).expect("valid")),
         )))
         .with_pipeline_time(Duration::from_secs(1))

crates/iroha/tests/pagination.rs

@@ -15,10 +15,7 @@ fn limits_should_work() -> Result<()> {
 
     let vec = client
         .query(FindAssetsDefinitions::new())
-        .with_pagination(Pagination {
-            limit: Some(nonzero!(7_u64)),
-            offset: 1,
-        })
+        .with_pagination(Pagination::new(Some(nonzero!(7_u64)), 1))
         .execute_all()?;
     assert_eq!(vec.len(), 7);
     Ok(())
@@ -33,10 +30,7 @@ fn reported_length_should_be_accurate() -> Result<()> {
 
     let mut iter = client
         .query(FindAssetsDefinitions::new())
-        .with_pagination(Pagination {
-            limit: Some(nonzero!(7_u64)),
-            offset: 1,
-        })
+        .with_pagination(Pagination::new(Some(nonzero!(7_u64)), 1))
         .with_fetch_size(FetchSize::new(Some(nonzero!(3_u64))))
         .execute()?;
 
@@ -68,10 +62,7 @@ fn fetch_size_should_work() -> Result<()> {
     let query = QueryWithParams::new(
         QueryWithFilter::new(FindAssetsDefinitions::new(), CompoundPredicate::PASS).into(),
         QueryParams::new(
-            Pagination {
-                limit: Some(nonzero!(7_u64)),
-                offset: 1,
-            },
+            Pagination::new(Some(nonzero!(7_u64)), 1),
             Sorting::default(),
             FetchSize::new(Some(nonzero!(3_u64))),
         ),

crates/iroha/tests/queries/asset.rs

@@ -78,7 +78,7 @@ fn find_asset_total_quantity() -> Result<()> {
             .query(FindAssetsDefinitions::new())
             .filter_with(|asset_definition| asset_definition.id.eq(definition_id.clone()))
             .execute_single()?
-            .total_quantity)
+            .total_quantity())
     };
 
     // Assert that initial total quantity before any registrations and unregistrations is zero
@@ -154,7 +154,7 @@ where
             .query(FindAssetsDefinitions::new())
             .filter_with(|asset_definition| asset_definition.id.eq(definition_id.clone()))
             .execute_single()?
-            .total_quantity)
+            .total_quantity())
     };
 
     // Assert that initial total quantity before any burns and mints is zero

crates/iroha/tests/set_parameter.rs

@@ -9,22 +9,22 @@ use nonzero_ext::nonzero;
 #[test]
 fn can_change_parameter_value() -> Result<()> {
     let (network, _rt) = NetworkBuilder::new()
-        .with_genesis_instruction(SetParameter(Parameter::Block(
+        .with_genesis_instruction(SetParameter::new(Parameter::Block(
             BlockParameter::MaxTransactions(nonzero!(16u64)),
         )))
         .start_blocking()?;
     let test_client = network.client();
 
     let old_params: Parameters = test_client.query_single(FindParameters::new())?;
-    assert_eq!(old_params.block.max_transactions, nonzero!(16u64));
+    assert_eq!(old_params.block().max_transactions(), nonzero!(16u64));
 
     let new_value = nonzero!(32u64);
-    test_client.submit_blocking(SetParameter(Parameter::Block(
+    test_client.submit_blocking(SetParameter::new(Parameter::Block(
         BlockParameter::MaxTransactions(new_value),
     )))?;
 
     let params = test_client.query_single(FindParameters::new())?;
-    assert_eq!(params.block.max_transactions, new_value);
+    assert_eq!(params.block().max_transactions(), new_value);
 
     Ok(())
 }

crates/iroha/tests/sorting.rs

@@ -22,10 +22,7 @@ fn correct_pagination_assets_after_creating_new_one() {
     const N_ASSETS: usize = 12;
     // 0 < pagination.start < missing_idx < pagination.end < N_ASSETS
     let missing_indices = vec![N_ASSETS / 2];
-    let pagination = Pagination {
-        limit: Some(nonzero!(N_ASSETS as u64 / 3)),
-        offset: N_ASSETS as u64 / 3,
-    };
+    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"));
 

crates/iroha/tests/triggers/by_call_trigger.rs

@@ -342,7 +342,7 @@ fn only_account_with_permission_can_register_trigger() -> Result<()> {
         .filter_with(|trigger| trigger.id.eq(trigger_id.clone()))
         .execute_single()?;
 
-    assert_eq!(found_trigger.id, trigger_id);
+    assert_eq!(*found_trigger.id(), trigger_id);
 
     Ok(())
 }
@@ -375,17 +375,17 @@ fn unregister_trigger() -> Result<()> {
         .query(FindTriggers::new())
         .filter_with(|trigger| trigger.id.eq(trigger_id.clone()))
         .execute_single()?;
-    let found_action = found_trigger.action;
-    let Executable::Instructions(found_instructions) = found_action.executable else {
+    let found_action = found_trigger.action();
+    let Executable::Instructions(found_instructions) = found_action.executable() else {
         panic!("Expected instructions");
     };
     let found_trigger = Trigger::new(
-        found_trigger.id,
+        found_trigger.id().clone(),
         Action::new(
-            Executable::Instructions(found_instructions),
-            found_action.repeats,
-            found_action.authority,
-            found_action.filter,
+            Executable::Instructions(found_instructions.to_owned()),
+            found_action.repeats(),
+            found_action.authority().clone(),
+            found_action.filter().clone(),
         ),
     );
     assert_eq!(found_trigger, trigger);

crates/iroha/tests/triggers/orphans.rs

@@ -5,13 +5,12 @@ use iroha::{
 use iroha_test_network::*;
 use iroha_test_samples::gen_account_in;
 
-fn find_trigger(iroha: &Client, trigger_id: &TriggerId) -> Option<TriggerId> {
+fn find_trigger(iroha: &Client, trigger_id: &TriggerId) -> Option<Trigger> {
     iroha
         .query(FindTriggers::new())
         .filter_with(|trigger| trigger.id.eq(trigger_id.clone()))
         .execute_single()
         .ok()
-        .map(|trigger| trigger.id)
 }
 
 fn set_up_trigger(iroha: &Client) -> eyre::Result<(DomainId, AccountId, TriggerId)> {
@@ -45,9 +44,10 @@ fn trigger_must_be_removed_on_action_authority_account_removal() -> eyre::Result
     let (network, _rt) = NetworkBuilder::new().start_blocking()?;
     let iroha = network.client();
     let (_, the_one_who_fails, fail_on_account_events) = set_up_trigger(&iroha)?;
+    let trigger = find_trigger(&iroha, &fail_on_account_events);
     assert_eq!(
-        find_trigger(&iroha, &fail_on_account_events),
-        Some(fail_on_account_events.clone())
+        trigger.as_ref().map(Identifiable::id),
+        Some(&fail_on_account_events.clone())
     );
     iroha.submit_blocking(Unregister::account(the_one_who_fails.clone()))?;
     assert_eq!(find_trigger(&iroha, &fail_on_account_events), None);
@@ -59,9 +59,10 @@ fn trigger_must_be_removed_on_action_authority_domain_removal() -> eyre::Result<
     let (network, _rt) = NetworkBuilder::new().start_blocking()?;
     let iroha = network.client();
     let (failand, _, fail_on_account_events) = set_up_trigger(&iroha)?;
+    let trigger = find_trigger(&iroha, &fail_on_account_events);
     assert_eq!(
-        find_trigger(&iroha, &fail_on_account_events),
-        Some(fail_on_account_events.clone())
+        trigger.as_ref().map(Identifiable::id),
+        Some(&fail_on_account_events.clone())
     );
     iroha.submit_blocking(Unregister::domain(failand.clone()))?;
     assert_eq!(find_trigger(&iroha, &fail_on_account_events), None);

crates/iroha/tests/triggers/time_trigger.rs

@@ -40,9 +40,7 @@ fn mint_asset_after_3_sec() -> Result<()> {
     let account_id = ALICE_ID.clone();
     let asset_id = AssetId::new(asset_definition_id.clone(), account_id.clone());
 
-    let init_quantity = test_client.query_single(FindAssetQuantityById {
-        id: asset_id.clone(),
-    })?;
+    let init_quantity = test_client.query_single(FindAssetQuantityById::new(asset_id.clone()))?;
 
     let start_time = curr_time();
     assert!(
@@ -64,18 +62,16 @@ fn mint_asset_after_3_sec() -> Result<()> {
 
     // Schedule start is in the future so trigger isn't executed after creating a new block
     test_client.submit_blocking(Log::new(Level::DEBUG, "Just to create block".to_string()))?;
-    let after_registration_quantity = test_client.query_single(FindAssetQuantityById {
-        id: asset_id.clone(),
-    })?;
+    let after_registration_quantity =
+        test_client.query_single(FindAssetQuantityById::new(asset_id.clone()))?;
     assert_eq!(init_quantity, after_registration_quantity);
 
     // Sleep long enough that trigger start is in the past
     std::thread::sleep(network.pipeline_time());
     test_client.submit_blocking(Log::new(Level::DEBUG, "Just to create block".to_string()))?;
 
-    let after_wait_quantity = test_client.query_single(FindAssetQuantityById {
-        id: asset_id.clone(),
-    })?;
+    let after_wait_quantity =
+        test_client.query_single(FindAssetQuantityById::new(asset_id.clone()))?;
     // Schedule is in the past now so trigger is executed
     assert_eq!(
         init_quantity.checked_add(1u32.into()).unwrap(),
@@ -168,7 +164,7 @@ fn mint_nft_for_every_user_every_1_sec() -> Result<()> {
     let start_time = curr_time() + offset;
     let schedule = TimeSchedule::starting_at(start_time).with_period(TRIGGER_PERIOD);
 
-    let filter = TimeEventFilter(ExecutionTime::Schedule(schedule));
+    let filter = TimeEventFilter::new(ExecutionTime::Schedule(schedule));
     let register_trigger = Register::trigger(Trigger::new(
         "mint_nft_for_all".parse()?,
         Action::new(

crates/iroha/tests/triggers/trigger_rollback.rs

@@ -36,9 +36,7 @@ fn failed_trigger_revert() -> Result<()> {
     client.submit_blocking(call_trigger)?;
 
     //Then
-    let query_result = client
-        .query(FindAssetsDefinitions::new())
-        .execute_all()?;
+    let query_result = client.query(FindAssetsDefinitions::new()).execute_all()?;
     assert!(query_result
         .iter()
         .all(|asset_definition| asset_definition.id() != &asset_definition_id));

crates/iroha/tests/tx_history.rs

@@ -41,10 +41,7 @@ fn client_has_rejected_and_accepted_txs_should_return_tx_history() -> Result<()>
     let transactions = client
         .query(FindTransactions::new())
         .filter_with(|tx| tx.transaction.value.authority.eq(account_id.clone()))
-        .with_pagination(Pagination {
-            limit: Some(nonzero!(50_u64)),
-            offset: 1,
-        })
+        .with_pagination(Pagination::new(Some(nonzero!(50_u64)), 1))
         .execute_all()?;
     assert_eq!(transactions.len(), 50);