[refactor] hyperledger#4045: Use concrete key types

Signed-off-by: Daniil Polyakov <arjentix@gmail.com>

cli/src/lib.rs

@@ -274,7 +274,7 @@ impl Iroha {
             &config.block_sync,
             sumeragi.clone(),
             Arc::clone(&kura),
-            PeerId::new(&config.torii.p2p_addr, &config.public_key),
+            PeerId::new(config.torii.p2p_addr.clone(), config.public_key.clone()),
             network.clone(),
         )
         .start();
@@ -459,7 +459,8 @@ impl Iroha {
                 // FIXME: don't like neither the message nor inability to throw Result to the outside
                 .expect("Cannot proceed without working subscriptions");
 
-            // NOTE: Triggered by tokio::select
+            // See https://github.com/tokio-rs/tokio/issues/5616 and
+            // https://github.com/rust-lang/rust-clippy/issues/10636
             #[allow(clippy::redundant_pub_crate)]
             loop {
                 tokio::select! {

cli/src/samples.rs

@@ -30,16 +30,10 @@ pub fn get_trusted_peers(public_key: Option<&PublicKey>) -> HashSet<PeerId> {
         ),
     ]
     .iter()
-    .map(|(a, k)| PeerId {
-        address: a.parse().expect("Valid"),
-        public_key: PublicKey::from_str(k).unwrap(),
-    })
+    .map(|(a, k)| PeerId::new(a.parse().expect("Valid"), PublicKey::from_str(k).unwrap()))
     .collect();
     if let Some(pubkey) = public_key {
-        trusted_peers.insert(PeerId {
-            address: DEFAULT_TORII_P2P_ADDR.clone(),
-            public_key: pubkey.clone(),
-        });
+        trusted_peers.insert(PeerId::new(DEFAULT_TORII_P2P_ADDR.clone(), pubkey.clone()));
     }
     trusted_peers
 }

client/benches/tps/utils.rs

@@ -225,9 +225,7 @@ impl MeasurerUnit {
                                 .with_instructions([instruction]);
                         transaction.set_nonce(nonce); // Use nonce to avoid transaction duplication within the same thread
 
-                        let transaction = submitter
-                            .sign_transaction(transaction)
-                            .expect("Failed to sign transaction");
+                        let transaction = submitter.sign_transaction(transaction);
                         if let Err(error) = submitter.submit_transaction(&transaction) {
                             iroha_logger::error!(?error, "Failed to submit transaction");
                         }

client/examples/tutorial.rs

@@ -74,9 +74,7 @@ fn domain_registration_test(config: &Configuration) -> Result<(), Error> {
     // Prepare a transaction
     let metadata = UnlimitedMetadata::default();
     let instructions: Vec<InstructionBox> = vec![create_looking_glass.into()];
-    let tx = iroha_client
-        .build_transaction(instructions, metadata)
-        .wrap_err("Error building a domain registration transaction")?;
+    let tx = iroha_client.build_transaction(instructions, metadata);
     // #endregion domain_register_example_prepare_tx
 
     // #region domain_register_example_submit_tx
@@ -148,7 +146,7 @@ fn account_registration_test(config: &Configuration) -> Result<(), Error> {
     // Account's RegisterBox
     let metadata = UnlimitedMetadata::new();
     let instructions: Vec<InstructionBox> = vec![create_account.into()];
-    let tx = iroha_client.build_transaction(instructions, metadata)?;
+    let tx = iroha_client.build_transaction(instructions, metadata);
     // #endregion register_account_prepare_tx
 
     // #region register_account_submit_tx

client/src/client.rs

@@ -63,30 +63,17 @@ pub type QueryResult<T> = core::result::Result<T, ClientQueryError>;
 /// Trait for signing transactions
 pub trait Sign {
     /// Sign transaction with provided key pair.
-    ///
-    /// # Errors
-    ///
-    /// Fails if signature creation fails
-    fn sign(
-        self,
-        key_pair: crate::crypto::KeyPair,
-    ) -> Result<SignedTransaction, crate::crypto::error::Error>;
+    fn sign(self, key_pair: crate::crypto::KeyPair) -> SignedTransaction;
 }
 
 impl Sign for TransactionBuilder {
-    fn sign(
-        self,
-        key_pair: crate::crypto::KeyPair,
-    ) -> Result<SignedTransaction, crate::crypto::error::Error> {
+    fn sign(self, key_pair: crate::crypto::KeyPair) -> SignedTransaction {
         self.sign(key_pair)
     }
 }
 
 impl Sign for SignedTransaction {
-    fn sign(
-        self,
-        key_pair: crate::crypto::KeyPair,
-    ) -> Result<SignedTransaction, crate::crypto::error::Error> {
+    fn sign(self, key_pair: crate::crypto::KeyPair) -> SignedTransaction {
         self.sign(key_pair)
     }
 }
@@ -468,7 +455,7 @@ impl Client {
         &self,
         instructions: impl Into<Executable>,
         metadata: UnlimitedMetadata,
-    ) -> Result<SignedTransaction> {
+    ) -> SignedTransaction {
         let tx_builder = TransactionBuilder::new(self.chain_id.clone(), self.account_id.clone());
 
         let mut tx_builder = match instructions.into() {
@@ -487,27 +474,22 @@ impl Client {
         tx_builder
             .with_metadata(metadata)
             .sign(self.key_pair.clone())
-            .wrap_err("Failed to sign transaction")
     }
 
     /// Signs transaction
     ///
     /// # Errors
     /// Fails if signature generation fails
-    pub fn sign_transaction<Tx: Sign>(&self, transaction: Tx) -> Result<SignedTransaction> {
-        transaction
-            .sign(self.key_pair.clone())
-            .wrap_err("Failed to sign transaction")
+    pub fn sign_transaction<Tx: Sign>(&self, transaction: Tx) -> SignedTransaction {
+        transaction.sign(self.key_pair.clone())
     }
 
     /// Signs query
     ///
     /// # Errors
     /// Fails if signature generation fails
-    pub fn sign_query(&self, query: QueryBuilder) -> Result<SignedQuery> {
-        query
-            .sign(self.key_pair.clone())
-            .wrap_err("Failed to sign query")
+    pub fn sign_query(&self, query: QueryBuilder) -> SignedQuery {
+        query.sign(self.key_pair.clone())
     }
 
     /// Instructions API entry point. Submits one Iroha Special Instruction to `Iroha` peers.
@@ -557,7 +539,7 @@ impl Client {
         instructions: impl IntoIterator<Item = impl Instruction>,
         metadata: UnlimitedMetadata,
     ) -> Result<HashOf<TransactionPayload>> {
-        self.submit_transaction(&self.build_transaction(instructions, metadata)?)
+        self.submit_transaction(&self.build_transaction(instructions, metadata))
     }
 
     /// Submit a prebuilt transaction.
@@ -746,15 +728,12 @@ impl Client {
         instructions: impl IntoIterator<Item = impl Instruction>,
         metadata: UnlimitedMetadata,
     ) -> Result<HashOf<TransactionPayload>> {
-        let transaction = self.build_transaction(instructions, metadata)?;
+        let transaction = self.build_transaction(instructions, metadata);
         self.submit_transaction_blocking(&transaction)
     }
 
     /// Lower-level Query API entry point. Prepares an http-request and returns it with an http-response handler.
     ///
-    /// # Errors
-    /// Fails if query signing fails.
-    ///
     /// # Examples
     ///
     /// ```ignore
@@ -817,12 +796,12 @@ impl Client {
         pagination: Pagination,
         sorting: Sorting,
         fetch_size: FetchSize,
-    ) -> Result<(DefaultRequestBuilder, QueryResponseHandler<R::Output>)>
+    ) -> (DefaultRequestBuilder, QueryResponseHandler<R::Output>)
     where
         <R::Output as TryFrom<Value>>::Error: Into<eyre::Error>,
     {
         let query_builder = QueryBuilder::new(request, self.account_id.clone()).with_filter(filter);
-        let request = self.sign_query(query_builder)?.encode_versioned();
+        let request = self.sign_query(query_builder).encode_versioned();
 
         let query_request = QueryRequest {
             torii_url: self.torii_url.clone(),
@@ -834,10 +813,10 @@ impl Client {
             ),
         };
 
-        Ok((
+        (
             query_request.clone().assemble(),
             QueryResponseHandler::new(query_request),
-        ))
+        )
     }
 
     /// Create a request with pagination, sorting and add the filter.
@@ -858,7 +837,7 @@ impl Client {
     {
         iroha_logger::trace!(?request, %pagination, ?sorting, ?filter);
         let (req, mut resp_handler) =
-            self.prepare_query_request::<R>(request, filter, pagination, sorting, fetch_size)?;
+            self.prepare_query_request::<R>(request, filter, pagination, sorting, fetch_size);
 
         let response = req.build()?.send()?;
         let value = resp_handler.handle(&response)?;
@@ -1685,11 +1664,8 @@ mod tests {
         .expect("Client config should build as all required fields were provided");
         let client = Client::new(&cfg).expect("Invalid client configuration");
 
-        let build_transaction = || {
-            client
-                .build_transaction(Vec::<InstructionBox>::new(), UnlimitedMetadata::new())
-                .unwrap()
-        };
+        let build_transaction =
+            || client.build_transaction(Vec::<InstructionBox>::new(), UnlimitedMetadata::new());
         let tx1 = build_transaction();
         let tx2 = build_transaction();
         assert_ne!(tx1.payload().hash(), tx2.payload().hash());
@@ -1708,7 +1684,7 @@ mod tests {
                 tx.set_ttl(transaction_ttl);
             }
 
-            client.sign_transaction(tx).unwrap()
+            client.sign_transaction(tx)
         };
         assert_eq!(tx1.payload().hash(), tx2.payload().hash());
     }

client/tests/integration/asset.rs

@@ -106,7 +106,7 @@ fn client_add_asset_quantity_to_existing_asset_should_increase_asset_amount() ->
         AssetId::new(asset_definition_id.clone(), account_id.clone()),
     );
     let instructions: [InstructionBox; 2] = [create_asset.into(), mint.into()];
-    let tx = test_client.build_transaction(instructions, metadata)?;
+    let tx = test_client.build_transaction(instructions, metadata);
     test_client.submit_transaction(&tx)?;
     test_client.poll_request(client::asset::by_account_id(account_id), |result| {
         let assets = result.collect::<QueryResult<Vec<_>>>().expect("Valid");
@@ -137,7 +137,7 @@ fn client_add_big_asset_quantity_to_existing_asset_should_increase_asset_amount(
         AssetId::new(asset_definition_id.clone(), account_id.clone()),
     );
     let instructions: [InstructionBox; 2] = [create_asset.into(), mint.into()];
-    let tx = test_client.build_transaction(instructions, metadata)?;
+    let tx = test_client.build_transaction(instructions, metadata);
     test_client.submit_transaction(&tx)?;
     test_client.poll_request(client::asset::by_account_id(account_id), |result| {
         let assets = result.collect::<QueryResult<Vec<_>>>().expect("Valid");
@@ -169,7 +169,7 @@ fn client_add_asset_with_decimal_should_increase_asset_amount() -> Result<()> {
         AssetId::new(asset_definition_id.clone(), account_id.clone()),
     );
     let instructions: [InstructionBox; 2] = [create_asset.into(), mint.into()];
-    let tx = test_client.build_transaction(instructions, metadata)?;
+    let tx = test_client.build_transaction(instructions, metadata);
     test_client.submit_transaction(&tx)?;
     test_client.poll_request(client::asset::by_account_id(account_id.clone()), |result| {
         let assets = result.collect::<QueryResult<Vec<_>>>().expect("Valid");
@@ -281,8 +281,7 @@ fn find_rate_and_make_exchange_isi_should_succeed() {
         let grant_asset_transfer_tx =
             TransactionBuilder::new(chain_id, asset_id.account_id().clone())
                 .with_instructions([allow_alice_to_transfer_asset])
-                .sign(owner_keypair)
-                .expect("Failed to sign seller transaction");
+                .sign(owner_keypair);
 
         test_client
             .submit_transaction_blocking(&grant_asset_transfer_tx)

client/tests/integration/burn_public_keys.rs

@@ -19,12 +19,9 @@ fn submit(
         TransactionBuilder::new(chain_id, account_id)
             .with_instructions(instructions)
             .sign(keypair)
-            .unwrap()
     } else {
-        let tx = client
-            .build_transaction(instructions, UnlimitedMetadata::default())
-            .unwrap();
-        client.sign_transaction(tx).unwrap()
+        let tx = client.build_transaction(instructions, UnlimitedMetadata::default());
+        client.sign_transaction(tx)
     };
 
     (tx.hash(), client.submit_transaction_blocking(&tx))

client/tests/integration/domain_owner.rs

@@ -29,7 +29,7 @@ fn domain_owner_domain_permissions() -> Result<()> {
     // Asset definitions can't be registered by "bob@kingdom" by default
     let transaction = TransactionBuilder::new(chain_id.clone(), bob_id.clone())
         .with_instructions([Register::asset_definition(coin.clone())])
-        .sign(bob_keypair.clone())?;
+        .sign(bob_keypair.clone());
     let err = test_client
         .submit_transaction_blocking(&transaction)
         .expect_err("Tx should fail due to permissions");
@@ -57,7 +57,7 @@ fn domain_owner_domain_permissions() -> Result<()> {
     test_client.submit_blocking(Grant::permission(token.clone(), bob_id.clone()))?;
     let transaction = TransactionBuilder::new(chain_id, bob_id.clone())
         .with_instructions([Register::asset_definition(coin)])
-        .sign(bob_keypair)?;
+        .sign(bob_keypair);
     test_client.submit_transaction_blocking(&transaction)?;
     test_client.submit_blocking(Revoke::permission(token, bob_id.clone()))?;
 
@@ -175,7 +175,7 @@ fn domain_owner_asset_definition_permissions() -> Result<()> {
     let coin = AssetDefinition::quantity(coin_id.clone());
     let transaction = TransactionBuilder::new(chain_id, bob_id.clone())
         .with_instructions([Register::asset_definition(coin)])
-        .sign(bob_keypair)?;
+        .sign(bob_keypair);
     test_client.submit_transaction_blocking(&transaction)?;
 
     // check that "alice@wonderland" as owner of domain can transfer asset definitions in her domain
@@ -246,7 +246,7 @@ fn domain_owner_asset_permissions() -> Result<()> {
             Register::asset_definition(coin),
             Register::asset_definition(store),
         ])
-        .sign(bob_keypair)?;
+        .sign(bob_keypair);
     test_client.submit_transaction_blocking(&transaction)?;
 
     // check that "alice@wonderland" as owner of domain can register and unregister assets in her domain

client/tests/integration/events/data.rs

@@ -150,9 +150,7 @@ fn transaction_execution_should_produce_events(
 
     // submit transaction to produce events
     init_receiver.recv()?;
-    let transaction = client
-        .build_transaction(executable, UnlimitedMetadata::new())
-        .unwrap();
+    let transaction = client.build_transaction(executable, UnlimitedMetadata::new());
     client.submit_transaction_blocking(&transaction)?;
 
     // assertion

client/tests/integration/events/pipeline.rs

@@ -51,7 +51,7 @@ fn test_with_instruction_and_status_and_port(
 
     // Given
     let submitter = client;
-    let transaction = submitter.build_transaction(instruction, UnlimitedMetadata::new())?;
+    let transaction = submitter.build_transaction(instruction, UnlimitedMetadata::new());
     let hash = transaction.payload().hash();
     let mut handles = Vec::new();
     for listener in clients {

client/tests/integration/multisignature_transaction.rs

@@ -55,8 +55,8 @@ fn multisignature_transactions_should_wait_for_all_signatures() -> Result<()> {
     client_configuration.private_key = private_key1;
     let client = Client::new(&client_configuration)?;
     let instructions = [mint_asset.clone()];
-    let transaction = client.build_transaction(instructions, UnlimitedMetadata::new())?;
-    client.submit_transaction(&client.sign_transaction(transaction)?)?;
+    let transaction = client.build_transaction(instructions, UnlimitedMetadata::new());
+    client.submit_transaction(&client.sign_transaction(transaction))?;
     thread::sleep(pipeline_time);
 
     //Then
@@ -81,11 +81,11 @@ fn multisignature_transactions_should_wait_for_all_signatures() -> Result<()> {
     client_configuration.private_key = private_key2;
     let client_2 = Client::new(&client_configuration)?;
     let instructions = [mint_asset];
-    let transaction = client_2.build_transaction(instructions, UnlimitedMetadata::new())?;
+    let transaction = client_2.build_transaction(instructions, UnlimitedMetadata::new());
     let transaction = client_2
         .get_original_transaction(&transaction, 3, Duration::from_millis(100))?
         .expect("Found no pending transaction for this account.");
-    client_2.submit_transaction(&client_2.sign_transaction(transaction)?)?;
+    client_2.submit_transaction(&client_2.sign_transaction(transaction))?;
     thread::sleep(pipeline_time);
     let assets = client_1
         .request(request)?

client/tests/integration/non_mintable.rs

@@ -28,7 +28,7 @@ fn non_mintable_asset_can_be_minted_once_but_not_twice() -> Result<()> {
     );
 
     let instructions: [InstructionBox; 2] = [create_asset.into(), mint.clone().into()];
-    let tx = test_client.build_transaction(instructions, metadata)?;
+    let tx = test_client.build_transaction(instructions, metadata);
 
     // We can register and mint the non-mintable token
     test_client.submit_transaction(&tx)?;

client/tests/integration/offline_peers.rs

@@ -8,6 +8,7 @@ use iroha_client::{
 };
 use iroha_config::iroha::Configuration;
 use iroha_crypto::KeyPair;
+use iroha_primitives::addr::socket_addr;
 use test_network::*;
 use tokio::runtime::Runtime;
 
@@ -51,10 +52,10 @@ fn register_offline_peer() -> Result<()> {
 
     check_status(&peer_clients, 1);
 
-    let address = "128.0.0.2:8085".parse()?;
+    let address = socket_addr!(128.0.0.2:8085);
     let key_pair = KeyPair::generate().unwrap();
     let public_key = key_pair.public_key().clone();
-    let peer_id = PeerId::new(&address, &public_key);
+    let peer_id = PeerId::new(address, public_key);
     let register_peer = Register::peer(DataModelPeer::new(peer_id));
 
     // Wait for some time to allow peers to connect