[refactor]: Remove adt_const_generics nightly feature

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

cli/src/torii/routing.rs

@@ -26,7 +26,6 @@ use iroha_core::{
         isi::query::{Error as QueryError, ValidQueryRequest},
         permissions::prelude::*,
     },
-    tx::TransactionOrigin,
 };
 use iroha_crypto::SignatureOf;
 use iroha_data_model::{
@@ -109,9 +108,10 @@ pub(crate) async fn handle_instructions(
     transaction: VersionedSignedTransaction,
 ) -> Result<Empty> {
     let transaction: SignedTransaction = transaction.into_v1();
-    let transaction = VersionedAcceptedTransaction::from_transaction::<
-        { TransactionOrigin::ConsensusBlock },
-    >(transaction, &iroha_cfg.sumeragi.transaction_limits)
+    let transaction = VersionedAcceptedTransaction::from_transaction::<false>(
+        transaction,
+        &iroha_cfg.sumeragi.transaction_limits,
+    )
     .map_err(Error::AcceptTransaction)?;
     #[allow(clippy::map_err_ignore)]
     queue

core/benches/kura.rs

@@ -4,12 +4,7 @@ use std::{str::FromStr as _, sync::Arc};
 
 use byte_unit::Byte;
 use criterion::{criterion_group, criterion_main, Criterion};
-use iroha_core::{
-    kura::BlockStore,
-    prelude::*,
-    tx::{TransactionOrigin, TransactionValidator},
-    wsv::World,
-};
+use iroha_core::{kura::BlockStore, prelude::*, tx::TransactionValidator, wsv::World};
 use iroha_crypto::KeyPair;
 use iroha_data_model::prelude::*;
 use iroha_version::scale::EncodeVersioned;
@@ -38,11 +33,7 @@ async fn measure_block_size_for_n_validators(n_validators: u32) {
         max_instruction_number: 4096,
         max_wasm_size_bytes: 0,
     };
-    let tx =
-        VersionedAcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-            tx,
-            &transaction_limits,
-        )
+    let tx = VersionedAcceptedTransaction::from_transaction::<false>(tx, &transaction_limits)
         .expect("Failed to accept Transaction.");
     let dir = tempfile::tempdir().expect("Could not create tempfile.");
     let kura =

core/benches/validation.rs

@@ -5,7 +5,7 @@ use std::{collections::BTreeSet, str::FromStr as _, sync::Arc};
 use criterion::{criterion_group, criterion_main, Criterion};
 use iroha_core::{
     prelude::*,
-    tx::{AcceptedTransaction, TransactionOrigin, TransactionValidator},
+    tx::{AcceptedTransaction, TransactionValidator},
     wsv::World,
 };
 use iroha_data_model::prelude::*;
@@ -84,7 +84,7 @@ fn accept_transaction(criterion: &mut Criterion) {
     let mut failures_count = 0;
     let _ = criterion.bench_function("accept", |b| {
         b.iter(|| {
-            match AcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
+            match AcceptedTransaction::from_transaction::<false>(
                 transaction.clone(),
                 &TRANSACTION_LIMITS,
             ) {
@@ -113,12 +113,11 @@ fn sign_transaction(criterion: &mut Criterion) {
 
 fn validate_transaction(criterion: &mut Criterion) {
     let keys = KeyPair::generate().expect("Failed to generate keys");
-    let transaction =
-        AcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-            build_test_transaction(keys.clone()),
-            &TRANSACTION_LIMITS,
-        )
-        .expect("Failed to accept transaction.");
+    let transaction = AcceptedTransaction::from_transaction::<false>(
+        build_test_transaction(keys.clone()),
+        &TRANSACTION_LIMITS,
+    )
+    .expect("Failed to accept transaction.");
     let mut success_count = 0;
     let mut failure_count = 0;
     let _ = criterion.bench_function("validate", move |b| {
@@ -143,12 +142,11 @@ fn validate_transaction(criterion: &mut Criterion) {
 
 fn chain_blocks(criterion: &mut Criterion) {
     let keys = KeyPair::generate().expect("Failed to generate keys");
-    let transaction =
-        AcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-            build_test_transaction(keys),
-            &TRANSACTION_LIMITS,
-        )
-        .expect("Failed to accept transaction.");
+    let transaction = AcceptedTransaction::from_transaction::<false>(
+        build_test_transaction(keys),
+        &TRANSACTION_LIMITS,
+    )
+    .expect("Failed to accept transaction.");
     let block = PendingBlock::new(vec![transaction.into()], Vec::new());
     let mut previous_block_hash = block.clone().chain_first().hash();
     let mut success_count = 0;
@@ -167,12 +165,11 @@ fn chain_blocks(criterion: &mut Criterion) {
 
 fn sign_blocks(criterion: &mut Criterion) {
     let keys = KeyPair::generate().expect("Failed to generate keys");
-    let transaction =
-        AcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-            build_test_transaction(keys.clone()),
-            &TRANSACTION_LIMITS,
-        )
-        .expect("Failed to accept transaction.");
+    let transaction = AcceptedTransaction::from_transaction::<false>(
+        build_test_transaction(keys.clone()),
+        &TRANSACTION_LIMITS,
+    )
+    .expect("Failed to accept transaction.");
     let transaction_validator = TransactionValidator::new(
         TRANSACTION_LIMITS,
         Arc::new(AllowAll::new()),
@@ -211,12 +208,11 @@ fn validate_blocks(criterion: &mut Criterion) {
     assert!(domain.add_account(account).is_none());
     // Pepare test transaction
     let keys = KeyPair::generate().expect("Failed to generate keys");
-    let transaction =
-        AcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-            build_test_transaction(keys),
-            &TRANSACTION_LIMITS,
-        )
-        .expect("Failed to accept transaction.");
+    let transaction = AcceptedTransaction::from_transaction::<false>(
+        build_test_transaction(keys),
+        &TRANSACTION_LIMITS,
+    )
+    .expect("Failed to accept transaction.");
     let block = PendingBlock::new(vec![transaction.into()], Vec::new()).chain_first();
     let transaction_validator = TransactionValidator::new(
         TRANSACTION_LIMITS,

core/src/block.rs

@@ -29,7 +29,7 @@ use serde::Serialize;
 use crate::{
     prelude::*,
     sumeragi::network_topology::{Role, Topology},
-    tx::{TransactionOrigin, TransactionValidator, VersionedAcceptedTransaction},
+    tx::{TransactionValidator, VersionedAcceptedTransaction},
 };
 
 /// Default estimation of consensus duration
@@ -482,14 +482,14 @@ impl VersionedCandidateBlock {
     /// # Errors
     /// Forward errors from [`CandidateBlock::revalidate`]
     #[inline]
-    pub fn revalidate<const TX_ORIGIN: TransactionOrigin>(
+    pub fn revalidate<const IS_GENESIS: bool>(
         self,
         transaction_validator: &TransactionValidator,
         wsv: &WorldStateView,
         latest_block: Option<HashOf<VersionedCommittedBlock>>,
         block_height: u64,
     ) -> Result<SignedBlock, eyre::Report> {
-        self.into_v1().revalidate::<TX_ORIGIN>(
+        self.into_v1().revalidate::<IS_GENESIS>(
             transaction_validator,
             wsv,
             latest_block,
@@ -554,7 +554,7 @@ impl CandidateBlock {
     /// - Block header transaction hashes don't match with computed transaction hashes
     /// - Error during revalidation of individual transactions
     #[allow(clippy::too_many_lines)]
-    pub fn revalidate<const TX_ORIGIN: TransactionOrigin>(
+    pub fn revalidate<const IS_GENESIS: bool>(
         self,
         transaction_validator: &TransactionValidator,
         wsv: &WorldStateView,
@@ -620,7 +620,7 @@ impl CandidateBlock {
             .into_iter()
             .map(VersionedSignedTransaction::into_v1)
             .map(|tx| {
-                AcceptedTransaction::from_transaction::<TX_ORIGIN>(
+                AcceptedTransaction::from_transaction::<IS_GENESIS>(
                     tx,
                     &transaction_validator.transaction_limits,
                 )
@@ -646,7 +646,7 @@ impl CandidateBlock {
             .into_iter()
             .map(VersionedSignedTransaction::into_v1)
             .map(|tx| {
-                AcceptedTransaction::from_transaction::<TX_ORIGIN>(
+                AcceptedTransaction::from_transaction::<IS_GENESIS>(
                     tx,
                     &transaction_validator.transaction_limits,
                 )
@@ -1192,10 +1192,9 @@ mod tests {
         let tx = Transaction::new(alice_id, [create_asset_definition].into(), 4000)
             .sign(alice_keys)
             .expect("Valid");
-        let tx = crate::VersionedAcceptedTransaction::from_transaction::<
-            { TransactionOrigin::ConsensusBlock },
-        >(tx, &transaction_limits)
-        .expect("Valid");
+        let tx =
+            crate::VersionedAcceptedTransaction::from_transaction::<false>(tx, &transaction_limits)
+                .expect("Valid");
 
         // Creating a block of two identical transactions and validating it
         let transactions = vec![tx.clone(), tx];

core/src/genesis.rs

@@ -26,7 +26,7 @@ use tokio::{time, time::Duration};
 
 use crate::{
     sumeragi::network_topology::{GenesisBuilder as GenesisTopologyBuilder, Topology},
-    tx::{TransactionOrigin, VersionedAcceptedTransaction},
+    tx::VersionedAcceptedTransaction,
     IrohaNetwork,
 };
 
@@ -280,10 +280,8 @@ impl GenesisTransaction {
             GENESIS_TRANSACTIONS_TTL_MS,
         )
         .sign(genesis_key_pair)?;
-        VersionedAcceptedTransaction::from_transaction::<{ TransactionOrigin::GenesisBlock }>(
-            transaction,
-            limits,
-        )
+
+        VersionedAcceptedTransaction::from_transaction::<true>(transaction, limits)
     }
 
     /// Create a [`GenesisTransaction`] with the specified [`Domain`] and [`Account`].

core/src/lib.rs

@@ -1,8 +1,5 @@
 //! Iroha — A simple, enterprise-grade decentralized ledger.
 
-#![allow(incomplete_features)] // This feature is minor and breakage to be expected is going to be minimal.
-#![feature(adt_const_params)]
-
 pub mod block;
 pub mod block_sync;
 pub mod genesis;

core/src/queue.rs

@@ -330,7 +330,7 @@ mod tests {
     use rand::Rng as _;
 
     use super::*;
-    use crate::{kura::Kura, tx::TransactionOrigin, wsv::World, PeersIds};
+    use crate::{kura::Kura, wsv::World, PeersIds};
 
     fn accepted_tx(
         account_id: &str,
@@ -352,10 +352,8 @@ mod tests {
             max_instruction_number: 4096,
             max_wasm_size_bytes: 0,
         };
-        VersionedAcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-            tx, &limits,
-        )
-        .expect("Failed to accept Transaction.")
+        VersionedAcceptedTransaction::from_transaction::<false>(tx, &limits)
+            .expect("Failed to accept Transaction.")
     }
 
     pub fn world_with_test_domains(
@@ -708,10 +706,8 @@ mod tests {
             for key_pair in &key_pairs[1..] {
                 signed_tx = signed_tx.sign(key_pair.clone()).expect("Failed to sign");
             }
-            VersionedAcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-                signed_tx, &tx_limits,
-            )
-            .expect("Failed to accept Transaction.")
+            VersionedAcceptedTransaction::from_transaction::<false>(signed_tx, &tx_limits)
+                .expect("Failed to accept Transaction.")
         };
         // Check that fully signed transaction pass signature check
         assert!(matches!(
@@ -720,7 +716,7 @@ mod tests {
         ));
 
         let get_tx = |key_pair| {
-            VersionedAcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
+            VersionedAcceptedTransaction::from_transaction::<false>(
                 tx.clone().sign(key_pair).expect("Failed to sign."),
                 &tx_limits,
             )

core/src/smartcontracts/isi/query.rs

@@ -132,7 +132,7 @@ mod tests {
         block::{PendingBlock, VersionedCommittedBlock},
         kura::Kura,
         prelude::AllowAll,
-        tx::{TransactionOrigin, TransactionValidator},
+        tx::TransactionValidator,
         wsv::World,
         PeersIds,
     };
@@ -226,17 +226,13 @@ mod tests {
         let valid_tx = {
             let tx = Transaction::new(ALICE_ID.clone(), Vec::<Instruction>::new().into(), 4000)
                 .sign(ALICE_KEYS.clone())?;
-            crate::VersionedAcceptedTransaction::from_transaction::<
-                { TransactionOrigin::ConsensusBlock },
-            >(tx, &limits)?
+            crate::VersionedAcceptedTransaction::from_transaction::<false>(tx, &limits)?
         };
         let invalid_tx = {
             let isi = Instruction::Fail(FailBox::new("fail"));
             let tx = Transaction::new(ALICE_ID.clone(), vec![isi.clone(), isi].into(), 4000)
                 .sign(ALICE_KEYS.clone())?;
-            crate::VersionedAcceptedTransaction::from_transaction::<
-                { TransactionOrigin::ConsensusBlock },
-            >(tx, &huge_limits)?
+            crate::VersionedAcceptedTransaction::from_transaction::<false>(tx, &huge_limits)?
         };
 
         let mut transactions = vec![valid_tx; valid_tx_per_block];
@@ -404,9 +400,8 @@ mod tests {
             max_wasm_size_bytes: 0,
         };
 
-        let va_tx = crate::VersionedAcceptedTransaction::from_transaction::<
-            { TransactionOrigin::ConsensusBlock },
-        >(signed_tx, &tx_limits)?;
+        let va_tx =
+            crate::VersionedAcceptedTransaction::from_transaction::<false>(signed_tx, &tx_limits)?;
 
         let mut block = PendingBlock::new(Vec::new(), Vec::new());
         block.transactions.push(va_tx.clone());

core/src/sumeragi/main_loop.rs

@@ -10,7 +10,7 @@ use rand::seq::SliceRandom;
 use tracing::{span, Level};
 
 use super::*;
-use crate::{genesis::GenesisNetwork, sumeragi::tracing::instrument, tx::TransactionOrigin};
+use crate::{genesis::GenesisNetwork, sumeragi::tracing::instrument};
 
 /// Fault injection for consensus tests
 pub trait FaultInjection: Send + Sync + Sized + 'static {}
@@ -343,7 +343,7 @@ impl<F: FaultInjection> SumeragiWithFault<F> {
                                     "Genesis Round Peer is revalidating the block."
                                 );
                                 let _enter = span.enter();
-                                match block.revalidate::<{ TransactionOrigin::GenesisBlock }>(
+                                match block.revalidate::<true>(
                                     &self.transaction_validator,
                                     &state.wsv,
                                     state.latest_block_hash,
@@ -533,10 +533,8 @@ fn enqueue_transaction<F: FaultInjection>(
     let tx = tx.into_v1();
 
     let addr = &sumeragi.peer_id.address;
-    match VersionedAcceptedTransaction::from_transaction::<{ TransactionOrigin::ConsensusBlock }>(
-        tx,
-        &sumeragi.transaction_limits,
-    ) {
+    match VersionedAcceptedTransaction::from_transaction::<false>(tx, &sumeragi.transaction_limits)
+    {
         Ok(tx) => match sumeragi.queue.push(tx, wsv) {
             Ok(_) => {}
             Err(crate::queue::Failure {
@@ -1060,7 +1058,7 @@ fn vote_for_block<F: FaultInjection>(
         let span = span!(Level::TRACE, "block revalidation");
         let _enter = span.enter();
 
-        match block.revalidate::<{ TransactionOrigin::ConsensusBlock }>(
+        match block.revalidate::<false>(
             &sumeragi.transaction_validator,
             &state.wsv,
             state.latest_block_hash,