[refactor]: Update block and sumeragi code

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

cli/src/event.rs

@@ -58,7 +58,8 @@ impl Consumer {
     #[iroha_futures::telemetry_future]
     pub async fn new(mut stream: WebSocket) -> Result<Self> {
         let subscription_request: VersionedEventSubscriptionRequest = stream.recv().await?;
-        let EventSubscriptionRequest(filter) = subscription_request.into_v1();
+        let VersionedEventSubscriptionRequest::V1(EventSubscriptionRequest(filter)) =
+            subscription_request;
 
         Ok(Consumer { stream, filter })
     }

cli/src/lib.rs

@@ -9,7 +9,7 @@
     clippy::std_instead_of_core,
     clippy::std_instead_of_alloc
 )]
-use core::sync::atomic::{AtomicBool, Ordering};
+use core::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
 use color_eyre::eyre::{eyre, Result, WrapErr};
@@ -30,7 +30,7 @@ use iroha_core::{
     IrohaNetwork,
 };
 use iroha_data_model::prelude::*;
-use iroha_genesis::GenesisNetwork;
+use iroha_genesis::{GenesisNetwork, GENESIS_ACCOUNT_ID, GENESIS_DOMAIN_ID};
 use iroha_logger::prelude::span;
 use tokio::{
     signal,
@@ -149,15 +149,22 @@ impl NetworkRelay {
         use iroha_core::NetworkMessage::*;
 
         #[cfg(debug_assertions)]
-        if self.freeze_status.load(Ordering::SeqCst) {
+        if self
+            .freeze_status
+            .load(core::sync::atomic::Ordering::SeqCst)
+        {
             return;
         }
 
         match msg {
             SumeragiPacket(data) => {
-                self.sumeragi.incoming_message(data.into_v1());
+                let iroha_core::sumeragi::message::VersionedPacket::V1(data) = *data;
+                self.sumeragi.incoming_message(data);
+            }
+            BlockSync(data) => {
+                let iroha_core::block_sync::message::VersionedMessage::V1(data) = *data;
+                self.block_sync.message(data).await
             }
-            BlockSync(data) => self.block_sync.message(data.into_v1()).await,
             Health => {}
         }
     }
@@ -250,7 +257,7 @@ impl Iroha {
             let wsv_clone = wsv.clone();
 
             transaction_validator
-                .validate_every(genesis.iter().cloned(), &wsv_clone)
+                .validate_every::<true>(genesis.iter().cloned(), &wsv_clone)
                 .wrap_err("Transaction validation failed in genesis block")?;
             span.exit();
         }
@@ -374,6 +381,7 @@ impl Iroha {
         if let Some((substrate_telemetry, telemetry_future)) = telemetry {
             #[cfg(feature = "dev-telemetry")]
             {
+                // TODO: JoinHandle is just dropped here. It should be joined
                 iroha_telemetry::dev::start(&config.telemetry, telemetry_future)
                     .await
                     .wrap_err("Failed to setup telemetry for futures")?;
@@ -426,17 +434,15 @@ impl Iroha {
 }
 
 fn genesis_account(public_key: iroha_crypto::PublicKey) -> Account {
-    let genesis_account_id = AccountId::genesis();
-    Account::new(genesis_account_id.clone(), [public_key]).build(genesis_account_id)
+    Account::new(GENESIS_ACCOUNT_ID.clone(), [public_key]).build(GENESIS_ACCOUNT_ID.clone())
 }
 
 fn genesis_domain(configuration: &Configuration) -> Domain {
-    let genesis_account_id = AccountId::genesis();
     let account_public_key = &configuration.genesis.account_public_key;
-    let mut domain = Domain::new(DomainId::genesis()).build(genesis_account_id);
+    let mut domain = Domain::new(GENESIS_DOMAIN_ID.clone()).build(GENESIS_ACCOUNT_ID.clone());
 
     domain.accounts.insert(
-        <Account as Identifiable>::Id::genesis(),
+        GENESIS_ACCOUNT_ID.clone(),
         genesis_account(account_public_key.clone()),
     );
 

cli/src/torii/mod.rs

@@ -50,7 +50,7 @@ pub enum Error {
     Query(#[from] iroha_data_model::query::error::QueryExecutionFailure),
     /// Failed to accept transaction
     #[error("Failed to accept transaction: {0}")]
-    AcceptTransaction(#[from] iroha_data_model::transaction::error::AcceptTransactionFailure),
+    AcceptTransaction(#[from] iroha_genesis::AcceptTransactionFailure),
     /// Error while getting or setting configuration
     #[error("Configuration error: {0}")]
     Config(#[source] eyre::Report),

cli/src/torii/routing.rs

@@ -19,18 +19,16 @@ use iroha_config::{
 use iroha_core::smartcontracts::isi::query::ValidQueryRequest;
 use iroha_crypto::SignatureOf;
 use iroha_data_model::{
-    block::{
-        stream::{
-            BlockMessage, BlockSubscriptionRequest, VersionedBlockMessage,
-            VersionedBlockSubscriptionRequest,
-        },
-        VersionedCommittedBlock,
+    block::stream::{
+        BlockMessage, BlockSubscriptionRequest, VersionedBlockMessage,
+        VersionedBlockSubscriptionRequest,
     },
     predicate::PredicateBox,
     prelude::*,
     query,
     query::error::QueryExecutionFailure,
 };
+use iroha_genesis::AcceptedTransaction;
 #[cfg(feature = "telemetry")]
 use iroha_telemetry::metrics::Status;
 use pagination::{paginate, Paginate};
@@ -75,7 +73,11 @@ impl VerifiedQuery {
             )));
         }
         wsv.validator_view()
-            .validate(wsv, &self.payload.account_id, self.payload.query.clone())
+            .validate(
+                wsv,
+                &self.payload.account_id,
+                self.payload.query.clone().into(),
+            )
             .map_err(|err| QueryExecutionFailure::Permission(err.to_string()))?;
         Ok((
             ValidQueryRequest::new(self.payload.query),
@@ -106,12 +108,9 @@ pub(crate) async fn handle_instructions(
     sumeragi: Arc<Sumeragi>,
     transaction: VersionedSignedTransaction,
 ) -> Result<Empty> {
-    let transaction: SignedTransaction = transaction.into_v1();
     let transaction =
         AcceptedTransaction::accept::<false>(transaction, &iroha_cfg.sumeragi.transaction_limits)
-            .map_err(Error::AcceptTransaction)?
-            .into();
-    #[allow(clippy::map_err_ignore)]
+            .map_err(|(_tx, error)| Error::AcceptTransaction(error))?;
     queue
         .push(transaction, &sumeragi.wsv_mutex_access())
         .map_err(|queue::Failure { tx, err }| {
@@ -233,11 +232,9 @@ async fn handle_pending_transactions(
         queue
             .all_transactions(&sumeragi.wsv_mutex_access())
             .into_iter()
-            .map(VersionedAcceptedTransaction::into_v1)
-            .map(SignedTransaction::from)
+            .map(VersionedSignedTransaction::from)
             .paginate(pagination)
-            .collect::<PendingTransactions>()
-            .into(),
+            .collect::<VersionedPendingTransactions>(),
     ))
 }
 
@@ -283,7 +280,8 @@ async fn handle_post_configuration(
 #[iroha_futures::telemetry_future]
 async fn handle_blocks_stream(kura: Arc<Kura>, mut stream: WebSocket) -> eyre::Result<()> {
     let subscription_request: VersionedBlockSubscriptionRequest = stream.recv().await?;
-    let BlockSubscriptionRequest(mut from_height) = subscription_request.into_v1();
+    let VersionedBlockSubscriptionRequest::V1(BlockSubscriptionRequest(mut from_height)) =
+        subscription_request;
 
     let mut interval = tokio::time::interval(std::time::Duration::from_millis(10));
     loop {
@@ -313,7 +311,7 @@ async fn handle_blocks_stream(kura: Arc<Kura>, mut stream: WebSocket) -> eyre::R
                     stream
                         // TODO: to avoid clone `VersionedBlockMessage` could be split into sending and receiving parts
                         .send(VersionedBlockMessage::from(
-                            BlockMessage(VersionedCommittedBlock::clone(&block)),
+                            BlockMessage(VersionedSignedBlock::clone(&block)),
                         ))
                         .await?;
                     from_height += 1;
@@ -415,7 +413,6 @@ mod subscription {
 async fn handle_version(sumeragi: Arc<Sumeragi>) -> Json {
     use iroha_version::Version;
 
-    #[allow(clippy::expect_used)]
     let string = sumeragi
         .wsv_mutex_access()
         .latest_block_ref()
@@ -490,7 +487,6 @@ impl Torii {
         }
     }
 
-    #[allow(opaque_hidden_inferred_bound)]
     #[cfg(feature = "telemetry")]
     /// Helper function to create router. This router can tested without starting up an HTTP server
     fn create_telemetry_router(
@@ -528,7 +524,6 @@ impl Torii {
     }
 
     /// Helper function to create router. This router can tested without starting up an HTTP server
-    #[allow(opaque_hidden_inferred_bound)]
     pub(crate) fn create_api_router(
         &self,
     ) -> impl warp::Filter<Extract = impl warp::Reply> + Clone + Send {

client/Cargo.toml

@@ -46,7 +46,7 @@ futures-util = "0.3.25"
 [dev-dependencies]
 iroha_wasm_builder = { version = "=2.0.0-pre-rc.13", path = "../wasm_builder" }
 
-# TODO: These three activate `transparent_api` but client should never activate this feature.
+# TODO: These three activate `transparent-api` but client should never activate this feature.
 # Additionally there is a dependency on iroha_core in dev-dependencies in telemetry/derive
 # Hopefully, once the integration tests migration is finished these can be removed
 iroha = { path = "../cli", features = ["dev-telemetry", "telemetry"] }

client/benches/tps/utils.rs

@@ -126,8 +126,11 @@ impl Config {
                 let block = blocks
                     .next()
                     .expect("The block is not yet in WSV. Need more sleep?");
-                let block = block.as_v1();
-                (block.transactions.len(), block.rejected_transactions.len())
+                let payload = block.payload();
+                (
+                    payload.transactions().len(),
+                    payload.rejected_transactions.len(),
+                )
             })
             .fold((0, 0), |acc, pair| (acc.0 + pair.0, acc.1 + pair.1));
         #[allow(clippy::float_arithmetic, clippy::cast_precision_loss)]
@@ -182,7 +185,7 @@ impl MeasurerUnit {
             100_000,
         )
         .sign(keypair)?;
-        self.client.submit_transaction_blocking(grant_tx)?;
+        self.client.submit_transaction_blocking(&grant_tx)?;
 
         let mint_a_rose = MintBox::new(1_u32, asset_id);
         self.client.submit_blocking(mint_a_rose)?;
@@ -236,7 +239,7 @@ impl MeasurerUnit {
                         let transaction = submitter
                             .sign_transaction(transaction)
                             .expect("Failed to sign transaction");
-                        if let Err(error) = submitter.submit_transaction(transaction) {
+                        if let Err(error) = submitter.submit_transaction(&transaction) {
                             iroha_logger::error!(?error, "Failed to submit transaction");
                         }
                         nonce = nonce.wrapping_add(1);

client/examples/tutorial.rs

@@ -83,7 +83,7 @@ fn domain_registration_test(config: &Configuration) -> Result<(), Error> {
     // #region domain_register_example_submit_tx
     // Submit a prepared domain registration transaction
     iroha_client
-        .submit_transaction(tx)
+        .submit_transaction(&tx)
         .wrap_err("Failed to submit transaction")?;
     // #endregion domain_register_example_submit_tx
 
@@ -152,7 +152,7 @@ fn account_registration_test(config: &Configuration) -> Result<(), Error> {
 
     // #region register_account_submit_tx
     // Submit a prepared account registration transaction
-    iroha_client.submit_transaction(tx)?;
+    iroha_client.submit_transaction(&tx)?;
     // #endregion register_account_submit_tx
 
     // Finish the test successfully