A0-4341: Bump rust toolchain to 1.79

bin/chain-bootstrapper/src/chain_spec/commands.rs

@@ -61,7 +61,7 @@ impl BootstrapChainCmd {
                         .into(),
                 );
             }
-            authorities = account_ids.clone();
+            authorities.clone_from(&account_ids);
         } else if !authorities
             .iter()
             .all(|authority| account_ids.contains(authority))

bin/node/Cargo.toml

@@ -67,7 +67,6 @@ substrate-frame-rpc-system = { workspace = true }
 pallet-transaction-payment-rpc = { workspace = true }
 
 aleph-runtime = { workspace = true, optional = true }
-try-runtime-cli = { workspace = true, optional = true }
 
 [build-dependencies]
 substrate-build-script-utils = { workspace = true }
@@ -96,12 +95,6 @@ rocksdb = [
     "sc-client-db/rocksdb",
     "sc-service/rocksdb",
 ]
-try-runtime = [
-    "aleph-runtime-native",
-    "dep:try-runtime-cli",
-    "aleph-runtime?/try-runtime",
-    "try-runtime-cli?/try-runtime",
-]
 aleph-runtime-native = [
     "dep:aleph-runtime"
 ]

bin/node/src/aleph_node_rpc.rs

@@ -166,7 +166,7 @@ pub trait AlephNodeApi<BE> {
     #[method(name = "getBlockAuthor")]
     fn block_author(&self, hash: BlockHash) -> RpcResult<Option<AccountId>>;
 
-    ///
+    /// Whether the node is ready for operation.
     #[method(name = "ready")]
     fn ready(&self) -> RpcResult<bool>;
 

bin/node/src/cli.rs

@@ -71,6 +71,7 @@ impl SubstrateCli for Cli {
     }
 }
 
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, ClapSubcommand)]
 pub enum Subcommand {
     /// Key management cli utilities
@@ -95,14 +96,6 @@ pub enum Subcommand {
     /// Revert the chain to a previous state.
     Revert(sc_cli::RevertCmd),
 
-    /// Try some command against runtime state.
-    #[cfg(feature = "try-runtime")]
-    TryRuntime(try_runtime_cli::TryRuntimeCmd),
-
-    /// Try some command against runtime state. Note: `try-runtime` feature must be enabled.
-    #[cfg(not(feature = "try-runtime"))]
-    TryRuntime,
-
     /// The custom benchmark subcommand benchmarking runtime pallets.
     #[cfg(feature = "runtime-benchmarks")]
     #[clap(subcommand)]

bin/node/src/executor.rs

@@ -1,14 +1,10 @@
 //! This module declares an `AlephExecutor` which is either a
 //! * `WasmExecutor`, for production and test build (when no local debugging is required)
-//! * `NativeElseWasmExecutor` for `try-runtime`, `runtime-benchmarks` and local debugging builds
+//! * `NativeElseWasmExecutor` for `runtime-benchmarks` and local debugging builds
 
 use sc_service::Configuration;
 
-#[cfg(not(any(
-    feature = "runtime-benchmarks",
-    feature = "aleph-native-runtime",
-    feature = "try-runtime"
-)))]
+#[cfg(not(any(feature = "runtime-benchmarks", feature = "aleph-native-runtime",)))]
 pub mod aleph_executor {
     use sc_executor::WasmExecutor;
 
@@ -22,11 +18,7 @@ pub mod aleph_executor {
     }
 }
 
-#[cfg(any(
-    feature = "runtime-benchmarks",
-    feature = "aleph-native-runtime",
-    feature = "try-runtime"
-))]
+#[cfg(any(feature = "runtime-benchmarks", feature = "aleph-native-runtime",))]
 pub mod aleph_executor {
     use sc_executor::NativeElseWasmExecutor;
 

bin/node/src/lib.rs

@@ -9,10 +9,6 @@ mod service;
 
 pub use cli::{Cli, Subcommand};
 pub use config::Validator as ConfigValidator;
-#[cfg(any(
-    feature = "runtime-benchmarks",
-    feature = "aleph-native-runtime",
-    feature = "try-runtime"
-))]
+#[cfg(any(feature = "runtime-benchmarks", feature = "aleph-native-runtime"))]
 pub use executor::aleph_executor::ExecutorDispatch;
 pub use service::{new_authority, new_partial, ServiceComponents};

bin/node/src/main.rs

@@ -78,41 +78,6 @@ fn main() -> sc_cli::Result<()> {
                 Ok((cmd.run(client, backend, None), task_manager))
             })
         }
-        #[cfg(feature = "try-runtime")]
-        Some(Subcommand::TryRuntime(cmd)) => {
-            use aleph_node::ExecutorDispatch;
-            use primitives::{Block, MILLISECS_PER_BLOCK};
-            use sc_executor::{sp_wasm_interface::ExtendedHostFunctions, NativeExecutionDispatch};
-            use try_runtime_cli::block_building_info::timestamp_with_aura_info;
-
-            let runner = cli.create_runner(cmd)?;
-            runner.async_run(|config| {
-                let registry = config.prometheus_config.as_ref().map(|cfg| &cfg.registry);
-                let task_manager =
-                    sc_service::TaskManager::new(config.tokio_handle.clone(), registry)
-                        .map_err(|e| sc_cli::Error::Service(sc_service::Error::Prometheus(e)))?;
-
-                Ok((
-                    // TODO
-                    // warning: use of deprecated method `try_runtime_cli::TryRuntimeCmd::run`:
-                    // Substrate's `try-runtime` subcommand has been migrated to a standalone CLI
-                    // (https://github.com/paritytech/try-runtime-cli). It is no longer being
-                    // maintained here and will be removed entirely some time after January 2024.
-                    // Please remove this subcommand from your runtime and use the standalone CLI.
-                    cmd.run::<Block, ExtendedHostFunctions<
-                        sp_io::SubstrateHostFunctions,
-                        <ExecutorDispatch as NativeExecutionDispatch>::ExtendHostFunctions,
-                    >, _>(Some(timestamp_with_aura_info(
-                        MILLISECS_PER_BLOCK,
-                    ))),
-                    task_manager,
-                ))
-            })
-        }
-        #[cfg(not(feature = "try-runtime"))]
-        Some(Subcommand::TryRuntime) => Err("TryRuntime wasn't enabled when building the node. \
-        You can enable it with `--features try-runtime`."
-            .into()),
         #[cfg(feature = "runtime-benchmarks")]
         Some(Subcommand::Benchmark(cmd)) => {
             use aleph_node::ExecutorDispatch;

bin/runtime/src/lib.rs

@@ -419,7 +419,7 @@ pub struct U256ToBalance;
 
 impl Convert<sp_core::U256, Balance> for U256ToBalance {
     fn convert(n: sp_core::U256) -> Balance {
-        n.try_into().unwrap_or(Balance::max_value())
+        n.try_into().unwrap_or(Balance::MAX)
     }
 }
 

finality-aleph/src/abft/current/mod.rs

@@ -37,7 +37,7 @@ pub fn run_member<H, C, ADN, V>(
     multikeychain: Keychain,
     config: Config,
     network: WrappedNetwork<H::Unverified, ADN>,
-    data_provider: impl current_aleph_bft::DataProvider<AlephData<H::Unverified>> + Send + 'static,
+    data_provider: impl current_aleph_bft::DataProvider<AlephData<H::Unverified>> + 'static,
     ordered_data_interpreter: OrderedDataInterpreter<SubstrateChainInfoProvider<H, C>, H, V>,
     backup: ABFTBackup,
 ) -> Task

finality-aleph/src/abft/legacy/mod.rs

@@ -36,7 +36,7 @@ pub fn run_member<H, C, ADN, V>(
     multikeychain: Keychain,
     config: Config,
     network: WrappedNetwork<H::Unverified, ADN>,
-    data_provider: impl legacy_aleph_bft::DataProvider<AlephData<H::Unverified>> + Send + 'static,
+    data_provider: impl legacy_aleph_bft::DataProvider<AlephData<H::Unverified>> + 'static,
     ordered_data_interpreter: OrderedDataInterpreter<SubstrateChainInfoProvider<H, C>, H, V>,
     backup: ABFTBackup,
 ) -> Task

finality-aleph/src/abft/traits.rs

@@ -4,15 +4,10 @@ use std::{cmp::Ordering, fmt::Debug, hash::Hash as StdHash, marker::PhantomData,
 
 use futures::{channel::oneshot, Future};
 use network_clique::{SpawnHandleExt, SpawnHandleT};
-use parity_scale_codec::{Codec, Decode, Encode};
+use parity_scale_codec::{Decode, Encode};
 use sc_service::SpawnTaskHandle;
 use sp_runtime::traits::Hash as SpHash;
 
-/// A convenience trait for gathering all of the desired hash characteristics.
-pub trait Hash: AsRef<[u8]> + StdHash + Eq + Clone + Codec + Debug + Send + Sync {}
-
-impl<T: AsRef<[u8]> + StdHash + Eq + Clone + Codec + Debug + Send + Sync> Hash for T {}
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Wrapper<H: SpHash> {
     phantom: PhantomData<H>,

finality-aleph/src/block/mock/backend.rs

@@ -172,7 +172,7 @@ impl Finalizer<MockJustification> for Backend {
             None => panic!("finalizing block without specified parent: {header:?}"),
         };
 
-        if storage.blockchain.get(&parent_id).is_none() {
+        if !storage.blockchain.contains_key(&parent_id) {
             panic!("finalizing block without imported parent: {header:?}")
         }
 
@@ -352,10 +352,6 @@ impl ChainStatus<MockBlock, MockJustification> for Backend {
         Ok(FinalizedByDescendant(block.header.clone()))
     }
 
-    fn best_block(&self) -> Result<MockHeader, Self::Error> {
-        Err(Self::Error {})
-    }
-
     fn top_finalized(&self) -> Result<MockJustification, Self::Error> {
         let storage = self.inner.lock();
         let id = storage

finality-aleph/src/block/mod.rs

@@ -226,9 +226,6 @@ where
     /// the request is above the top finalized.
     fn finalized_at(&self, number: BlockNumber) -> Result<FinalizationStatus<J>, Self::Error>;
 
-    /// The header of the best block.
-    fn best_block(&self) -> Result<J::Header, Self::Error>;
-
     /// The justification of the top finalized block.
     fn top_finalized(&self) -> Result<J, Self::Error>;
 

finality-aleph/src/block/substrate/chain_status.rs

@@ -154,10 +154,6 @@ impl SubstrateChainStatus {
         }
     }
 
-    fn best_hash(&self) -> AlephHash {
-        self.info().best_hash
-    }
-
     fn finalized_hash(&self) -> AlephHash {
         self.info().finalized_hash
     }
@@ -225,13 +221,6 @@ impl ChainStatus<Block, Justification> for SubstrateChainStatus {
         }
     }
 
-    fn best_block(&self) -> Result<AlephHeader, Self::Error> {
-        let best_hash = self.best_hash();
-
-        self.header_for_hash(best_hash)?
-            .ok_or(Error::MissingHash(best_hash))
-    }
-
     fn top_finalized(&self) -> Result<Justification, Self::Error> {
         let finalized_hash = self.finalized_hash();
         let header = self

finality-aleph/src/crypto.rs

@@ -1,4 +1,7 @@
-use std::sync::Arc;
+use std::{
+    fmt::{Display, Error as FmtError, Formatter},
+    sync::Arc,
+};
 
 use parity_scale_codec::{Decode, Encode};
 use sc_keystore::{Keystore, LocalKeystore};
@@ -17,6 +20,20 @@ pub enum Error {
     Keystore(KeystoreError),
 }
 
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
+        use Error::*;
+        match self {
+            KeyMissing(auth_id) => {
+                write!(f, "no key for authority {auth_id:?}")
+            }
+            Keystore(err) => {
+                write!(f, "keystore error: {err}")
+            }
+        }
+    }
+}
+
 #[derive(PartialEq, Eq, Clone, Debug, Hash, Decode, Encode)]
 pub struct Signature(AuthoritySignature);
 

finality-aleph/src/network/mock.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use futures::channel::mpsc;
 use sc_keystore::LocalKeystore;
 use sp_keystore::Keystore as _;
 
@@ -10,25 +9,6 @@ use crate::{
     AuthorityId, NodeIndex,
 };
 
-#[derive(Clone)]
-pub struct Channel<T>(
-    pub mpsc::UnboundedSender<T>,
-    pub Arc<tokio::sync::Mutex<mpsc::UnboundedReceiver<T>>>,
-);
-
-impl<T> Channel<T> {
-    pub fn new() -> Self {
-        let (tx, rx) = mpsc::unbounded();
-        Channel(tx, Arc::new(tokio::sync::Mutex::new(rx)))
-    }
-}
-
-impl<T> Default for Channel<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 pub fn crypto_basics(
     num_crypto_basics: usize,
 ) -> (Vec<(NodeIndex, AuthorityPen)>, AuthorityVerifier) {

finality-aleph/src/network/tcp.rs

@@ -1,4 +1,9 @@
-use std::{io::Error as IoError, iter, net::ToSocketAddrs as _};
+use std::{
+    fmt::{Display as FmtDisplay, Error as FmtError, Formatter},
+    io::Error as IoError,
+    iter,
+    net::ToSocketAddrs as _,
+};
 
 use derive_more::{AsRef, Display};
 use log::info;
@@ -177,6 +182,20 @@ pub enum Error {
     AddressingInformation(AddressingInformationError),
 }
 
+impl FmtDisplay for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), FmtError> {
+        use Error::*;
+        match self {
+            Io(err) => {
+                write!(f, "IO error: {err}")
+            }
+            AddressingInformation(err) => {
+                write!(f, "problem with addressing information: {err:?}")
+            }
+        }
+    }
+}
+
 impl From<IoError> for Error {
     fn from(e: IoError) -> Self {
         Error::Io(e)

pallets/aleph/src/lib.rs

@@ -7,7 +7,7 @@ mod mock;
 mod tests;
 
 mod impls;
-mod traits;
+pub mod traits;
 
 use frame_support::{
     sp_runtime::BoundToRuntimeAppPublic,
@@ -378,19 +378,19 @@ pub mod pallet {
     impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
         type Key = T::AuthorityId;
 
-        fn on_genesis_session<'a, I: 'a>(validators: I)
+        fn on_genesis_session<'a, I>(validators: I)
         where
-            I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
+            I: 'a + Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
             T::AccountId: 'a,
         {
             let (_, authorities): (Vec<_>, Vec<_>) = validators.unzip();
             // it is guaranteed that the first validator set will also be used in the next session
             Self::initialize_authorities(authorities.as_slice(), authorities.as_slice());
         }
 
-        fn on_new_session<'a, I: 'a>(changed: bool, _: I, queued_validators: I)
+        fn on_new_session<'a, I>(changed: bool, _: I, queued_validators: I)
         where
-            I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
+            I: 'a + Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
             T::AccountId: 'a,
         {
             Self::update_emergency_finalizer();

pallets/elections/src/mock.rs

@@ -1,5 +1,3 @@
-#![cfg(test)]
-
 use frame_election_provider_support::{
     data_provider, DataProviderBounds, ElectionDataProvider, VoteWeight,
 };

pallets/elections/src/tests.rs

@@ -1,5 +1,3 @@
-#![cfg(test)]
-
 use frame_election_provider_support::{ElectionProvider, Support};
 use primitives::CommitteeSeats;
 use sp_core::bounded_vec;

rust-toolchain.toml

@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.77.0"
+channel = "1.79.0"
 targets = [ "wasm32-unknown-unknown" ]
 components = [ "rustfmt", "clippy", "rust-src" ]
 profile = "minimal"