[refactor]: Export iroha_crypto through iroha_client

client/benches/torii.rs

@@ -6,10 +6,9 @@ use criterion::{criterion_group, criterion_main, Criterion, Throughput};
 use iroha::samples::{construct_executor, get_config};
 use iroha_client::{
     client::{asset, Client},
+    crypto::KeyPair,
     data_model::prelude::*,
 };
-use iroha_crypto::KeyPair;
-use iroha_data_model::isi::InstructionBox;
 use iroha_genesis::{GenesisNetwork, RawGenesisBlockBuilder};
 use iroha_primitives::unique_vec;
 use iroha_version::Encode;

client/benches/tps/utils.rs

@@ -163,7 +163,8 @@ impl MeasurerUnit {
 
     /// Submit initial transactions for measurement
     fn ready(self) -> Result<Self> {
-        let keypair = iroha_crypto::KeyPair::generate().expect("Failed to generate KeyPair.");
+        let keypair =
+            iroha_client::crypto::KeyPair::generate().expect("Failed to generate KeyPair.");
 
         let account_id = account_id(self.name);
         let asset_id = asset_id(self.name);

client/examples/tutorial.rs

@@ -114,12 +114,12 @@ fn account_registration_test(config: &Configuration) -> Result<(), Error> {
     // #region register_account_crates
     use iroha_client::{
         client::Client,
+        crypto::KeyPair,
         data_model::{
             metadata::UnlimitedMetadata,
             prelude::{Account, AccountId, InstructionBox, Register},
         },
     };
-    use iroha_crypto::KeyPair;
     // #endregion register_account_crates
 
     // Create an Iroha client

client/src/client.rs

@@ -14,7 +14,6 @@ use eyre::{eyre, Result, WrapErr};
 use futures_util::StreamExt;
 use http_default::{AsyncWebSocketStream, WebSocketStream};
 use iroha_config::{client::Configuration, client_api::ConfigurationDTO, torii::uri};
-use iroha_crypto::{HashOf, KeyPair};
 use iroha_logger::prelude::*;
 use iroha_telemetry::metrics::Status;
 use iroha_version::prelude::*;
@@ -24,6 +23,7 @@ use url::Url;
 
 use self::{blocks_api::AsyncBlockStream, events_api::AsyncEventStream};
 use crate::{
+    crypto::{HashOf, KeyPair},
     data_model::{
         block::SignedBlock,
         isi::Instruction,
@@ -69,24 +69,24 @@ pub trait Sign {
     /// Fails if signature creation fails
     fn sign(
         self,
-        key_pair: iroha_crypto::KeyPair,
-    ) -> Result<SignedTransaction, iroha_crypto::error::Error>;
+        key_pair: crate::crypto::KeyPair,
+    ) -> Result<SignedTransaction, crate::crypto::error::Error>;
 }
 
 impl Sign for TransactionBuilder {
     fn sign(
         self,
-        key_pair: iroha_crypto::KeyPair,
-    ) -> Result<SignedTransaction, iroha_crypto::error::Error> {
+        key_pair: crate::crypto::KeyPair,
+    ) -> Result<SignedTransaction, crate::crypto::error::Error> {
         self.sign(key_pair)
     }
 }
 
 impl Sign for SignedTransaction {
     fn sign(
         self,
-        key_pair: iroha_crypto::KeyPair,
-    ) -> Result<SignedTransaction, iroha_crypto::error::Error> {
+        key_pair: crate::crypto::KeyPair,
+    ) -> Result<SignedTransaction, crate::crypto::error::Error> {
         self.sign(key_pair)
     }
 }
@@ -1699,8 +1699,8 @@ mod tests {
                     .parse()
                     .expect("Public key not in mulithash format"),
             ),
-            private_key: Some(iroha_crypto::PrivateKey::from_hex(
-            iroha_crypto::Algorithm::Ed25519,
+            private_key: Some(crate::crypto::PrivateKey::from_hex(
+            crate::crypto::Algorithm::Ed25519,
             "9AC47ABF59B356E0BD7DCBBBB4DEC080E302156A48CA907E47CB6AEA1D32719E7233BFC89DCBD68C19FDE6CE6158225298EC1131B6A130D1AEB454C1AB5183C0"
             ).expect("Private key not hex encoded")),
             account_id: Some(

client/src/lib.rs

@@ -13,7 +13,8 @@ pub mod samples {
         client::{Configuration, ConfigurationProxy},
         torii::uri::DEFAULT_API_ADDR,
     };
-    use iroha_crypto::KeyPair;
+
+    use crate::crypto::KeyPair;
 
     /// Get sample client configuration.
     pub fn get_client_config(key_pair: &KeyPair) -> Configuration {
@@ -38,4 +39,5 @@ pub mod samples {
     }
 }
 
+pub use iroha_crypto as crypto;
 pub use iroha_data_model as data_model;

client/tests/integration/asset.rs

@@ -3,10 +3,9 @@ use std::{str::FromStr as _, thread};
 use eyre::Result;
 use iroha_client::{
     client::{self, QueryResult},
+    crypto::{KeyPair, PublicKey},
     data_model::prelude::*,
 };
-use iroha_crypto::{KeyPair, PublicKey};
-use iroha_data_model::isi::InstructionBox;
 use iroha_primitives::fixed::Fixed;
 use serde_json::json;
 use test_network::*;

client/tests/integration/asset_propagation.rs

@@ -3,13 +3,12 @@ use std::{str::FromStr as _, thread};
 use eyre::Result;
 use iroha_client::{
     client::{self, QueryResult},
+    crypto::KeyPair,
     data_model::{
         parameter::{default::MAX_TRANSACTIONS_IN_BLOCK, ParametersBuilder},
         prelude::*,
     },
 };
-use iroha_crypto::KeyPair;
-use iroha_data_model::isi::InstructionBox;
 use test_network::*;
 
 use super::Configuration;

client/tests/integration/burn_public_keys.rs

@@ -1,8 +1,8 @@
 use iroha_client::{
     client::{account, transaction, Client},
+    crypto::{HashOf, KeyPair, PublicKey},
     data_model::{isi::Instruction, prelude::*, transaction::TransactionPayload},
 };
-use iroha_crypto::{HashOf, KeyPair, PublicKey};
 use test_network::*;
 
 fn submit(

client/tests/integration/domain_owner.rs

@@ -1,6 +1,8 @@
 use eyre::Result;
-use iroha_client::data_model::{account::SignatureCheckCondition, prelude::*};
-use iroha_crypto::KeyPair;
+use iroha_client::{
+    crypto::KeyPair,
+    data_model::{account::SignatureCheckCondition, prelude::*},
+};
 use serde_json::json;
 use test_network::*;
 

client/tests/integration/events/pipeline.rs

@@ -1,11 +1,13 @@
 use std::thread::{self, JoinHandle};
 
 use eyre::Result;
-use iroha_client::data_model::{
-    parameter::{default::MAX_TRANSACTIONS_IN_BLOCK, ParametersBuilder},
-    prelude::*,
+use iroha_client::{
+    crypto::HashOf,
+    data_model::{
+        parameter::{default::MAX_TRANSACTIONS_IN_BLOCK, ParametersBuilder},
+        prelude::*,
+    },
 };
-use iroha_crypto::HashOf;
 use test_network::*;
 
 use super::Configuration;
@@ -75,7 +77,7 @@ fn test_with_instruction_and_status_and_port(
 #[derive(Clone)]
 struct Checker {
     listener: iroha_client::client::Client,
-    hash: iroha_crypto::HashOf<TransactionPayload>,
+    hash: HashOf<TransactionPayload>,
 }
 
 impl Checker {

client/tests/integration/multiple_blocks_created.rs

@@ -3,13 +3,12 @@ use std::thread;
 use eyre::Result;
 use iroha_client::{
     client::{self, Client, QueryResult},
+    crypto::KeyPair,
     data_model::{
         parameter::{default::MAX_TRANSACTIONS_IN_BLOCK, ParametersBuilder},
         prelude::*,
     },
 };
-use iroha_crypto::KeyPair;
-use iroha_data_model::isi::InstructionBox;
 use test_network::*;
 
 use super::Configuration;

client/tests/integration/multisignature_account.rs

@@ -3,9 +3,9 @@ use std::thread;
 use eyre::Result;
 use iroha_client::{
     client::{self, Client, QueryResult},
+    crypto::KeyPair,
     data_model::prelude::*,
 };
-use iroha_crypto::KeyPair;
 use test_network::*;
 
 use super::Configuration;

client/tests/integration/multisignature_transaction.rs

@@ -3,13 +3,13 @@ use std::{str::FromStr as _, thread, time::Duration};
 use eyre::Result;
 use iroha_client::{
     client::{self, Client, QueryResult},
+    crypto::KeyPair,
     data_model::{
         parameter::{default::MAX_TRANSACTIONS_IN_BLOCK, ParametersBuilder},
         prelude::*,
     },
 };
 use iroha_config::client::Configuration as ClientConfiguration;
-use iroha_crypto::KeyPair;
 use test_network::*;
 
 use super::Configuration;

client/tests/integration/permissions.rs

@@ -3,6 +3,7 @@ use std::{str::FromStr as _, thread, time::Duration};
 use eyre::Result;
 use iroha_client::{
     client::{self, Client, QueryResult},
+    crypto::KeyPair,
     data_model::prelude::*,
 };
 use iroha_genesis::GenesisNetwork;
@@ -80,7 +81,7 @@ fn permissions_disallow_asset_transfer() {
     let asset_definition_id: AssetDefinitionId = "xor#wonderland".parse().expect("Valid");
     let create_asset =
         Register::asset_definition(AssetDefinition::quantity(asset_definition_id.clone()));
-    let mouse_keypair = iroha_crypto::KeyPair::generate().expect("Failed to generate KeyPair.");
+    let mouse_keypair = KeyPair::generate().expect("Failed to generate KeyPair.");
 
     let alice_start_assets = get_assets(&iroha_client, &alice_id);
     iroha_client
@@ -134,7 +135,7 @@ fn permissions_disallow_asset_burn() {
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
     let create_asset =
         Register::asset_definition(AssetDefinition::quantity(asset_definition_id.clone()));
-    let mouse_keypair = iroha_crypto::KeyPair::generate().expect("Failed to generate KeyPair.");
+    let mouse_keypair = KeyPair::generate().expect("Failed to generate KeyPair.");
 
     let alice_start_assets = get_assets(&iroha_client, &alice_id);
 
@@ -204,7 +205,7 @@ fn permissions_differ_not_only_by_names() {
 
     let alice_id: AccountId = "alice@wonderland".parse().expect("Valid");
     let mouse_id: AccountId = "mouse@wonderland".parse().expect("Valid");
-    let mouse_keypair = iroha_crypto::KeyPair::generate().expect("Failed to generate KeyPair.");
+    let mouse_keypair = KeyPair::generate().expect("Failed to generate KeyPair.");
 
     // Registering `Store` asset definitions
     let hat_definition_id: AssetDefinitionId = "hat#wonderland".parse().expect("Valid");
@@ -300,7 +301,7 @@ fn stored_vs_granted_token_payload() -> Result<()> {
     let create_asset =
         Register::asset_definition(AssetDefinition::store(asset_definition_id.clone()));
     let mouse_id: AccountId = "mouse@wonderland".parse().expect("Valid");
-    let mouse_keypair = iroha_crypto::KeyPair::generate().expect("Failed to generate KeyPair.");
+    let mouse_keypair = KeyPair::generate().expect("Failed to generate KeyPair.");
     let new_mouse_account = Account::new(mouse_id.clone(), [mouse_keypair.public_key().clone()]);
     let instructions: [InstructionBox; 2] = [
         Register::account(new_mouse_account).into(),

client/tests/integration/queries/asset.rs

@@ -1,14 +1,14 @@
 use eyre::Result;
 use iroha_client::{
     client::{Client, ClientQueryError},
+    crypto::KeyPair,
     data_model::{
         asset::AssetValue,
+        isi::Instruction,
         prelude::*,
         query::{asset::FindTotalAssetQuantityByAssetDefinitionId, error::QueryExecutionFail},
     },
 };
-use iroha_crypto::KeyPair;
-use iroha_data_model::isi::Instruction;
 use iroha_primitives::fixed::Fixed;
 use test_network::*;
 

client/tests/integration/roles.rs

@@ -3,6 +3,7 @@ use std::str::FromStr as _;
 use eyre::Result;
 use iroha_client::{
     client::{self, QueryResult},
+    crypto::KeyPair,
     data_model::prelude::*,
 };
 use serde_json::json;
@@ -52,7 +53,7 @@ fn register_and_grant_role_for_metadata_access() -> Result<()> {
     let mouse_id = AccountId::from_str("mouse@wonderland")?;
 
     // Registering Mouse
-    let mouse_key_pair = iroha_crypto::KeyPair::generate()?;
+    let mouse_key_pair = KeyPair::generate()?;
     let register_mouse = Register::account(Account::new(
         mouse_id.clone(),
         [mouse_key_pair.public_key().clone()],

client/tests/integration/transfer_asset.rs

@@ -1,9 +1,8 @@
 use iroha_client::{
     client::{self, QueryResult},
-    data_model::{prelude::*, Registered},
+    crypto::KeyPair,
+    data_model::{isi::Instruction, prelude::*, Registered},
 };
-use iroha_crypto::KeyPair;
-use iroha_data_model::isi::Instruction;
 use iroha_primitives::fixed::Fixed;
 use test_network::*;
 

client/tests/integration/unregister_peer.rs

@@ -3,12 +3,12 @@ use std::thread;
 use eyre::Result;
 use iroha_client::{
     client::{self, QueryResult},
+    crypto::KeyPair,
     data_model::{
         parameter::{default::MAX_TRANSACTIONS_IN_BLOCK, ParametersBuilder},
         prelude::*,
     },
 };
-use iroha_crypto::KeyPair;
 use test_network::*;
 
 use super::Configuration;

client/tests/integration/upgrade.rs

@@ -3,9 +3,9 @@ use std::{path::Path, str::FromStr as _};
 use eyre::Result;
 use iroha_client::{
     client::{self, Client, QueryResult},
+    crypto::KeyPair,
     data_model::prelude::*,
 };
-use iroha_crypto::KeyPair;
 use iroha_logger::info;
 use serde_json::json;
 use test_network::*;

client_cli/Cargo.toml

@@ -25,7 +25,6 @@ maintenance = { status = "actively-developed" }
 [dependencies]
 iroha_client = { workspace = true }
 iroha_primitives = { workspace = true }
-iroha_crypto = { workspace = true }
 iroha_config = { workspace = true }
 
 color-eyre = { workspace = true }

smart_contract/executor/derive/src/validate.rs

@@ -58,7 +58,11 @@ impl FromAttributes for ValidateAttribute {
                 continue;
             }
 
-            let Some(list) = accumulator.handle(attr.meta.require_list().map_err(darling::Error::from)) else { continue; };
+            let Some(list) =
+                accumulator.handle(attr.meta.require_list().map_err(darling::Error::from))
+            else {
+                continue;
+            };
             let tokens = &list.tokens;
 
             if path.is_ident("validate") {