chore: bump rust version to latest nightly

common/numerated/src/interval.rs

@@ -441,7 +441,7 @@ mod tests {
     #[test]
     fn size() {
         assert_eq!(Interval::<u8>::try_from(11..111).unwrap().size(), Some(100),);
-        assert_eq!(Interval::<u8>::try_from(..1).unwrap().size(), Some(1),);
+        assert_eq!(Interval::<u8>::from(..1).size(), Some(1),);
         assert_eq!(Interval::<u8>::from(..=1).size(), Some(2));
         assert_eq!(Interval::<u8>::from(1..).size(), Some(255));
         assert_eq!(Interval::<u8>::from(0..).size(), None);
@@ -452,15 +452,15 @@ mod tests {
             Interval::<u8>::try_from(11..111).unwrap().raw_size(),
             Some(100),
         );
-        assert_eq!(Interval::<u8>::try_from(..1).unwrap().raw_size(), Some(1),);
+        assert_eq!(Interval::<u8>::from(..1).raw_size(), Some(1),);
         assert_eq!(Interval::<u8>::from(..=1).raw_size(), Some(2));
         assert_eq!(Interval::<u8>::from(1..).raw_size(), Some(255));
         assert_eq!(Interval::<u8>::from(0..).raw_size(), None);
         assert_eq!(Interval::<u8>::from(..).raw_size(), None);
         assert_eq!(Interval::<u8>::try_from(1..1).unwrap().raw_size(), Some(0));
 
         assert_eq!(Interval::<i8>::try_from(-1..99).unwrap().size(), Some(-28)); // corresponds to 100 numeration
-        assert_eq!(Interval::<i8>::try_from(..1).unwrap().size(), Some(1)); // corresponds to 129 numeration
+        assert_eq!(Interval::<i8>::from(..1).size(), Some(1)); // corresponds to 129 numeration
         assert_eq!(Interval::<i8>::from(..=1).size(), Some(2)); // corresponds to 130 numeration
         assert_eq!(Interval::<i8>::from(1..).size(), Some(-1)); // corresponds to 127 numeration
         assert_eq!(Interval::<i8>::from(0..).size(), Some(0)); // corresponds to 128 numeration
@@ -471,7 +471,7 @@ mod tests {
             Interval::<i8>::try_from(-1..99).unwrap().raw_size(),
             Some(100)
         );
-        assert_eq!(Interval::<i8>::try_from(..1).unwrap().raw_size(), Some(129));
+        assert_eq!(Interval::<i8>::from(..1).raw_size(), Some(129));
         assert_eq!(Interval::<i8>::from(..=1).raw_size(), Some(130));
         assert_eq!(Interval::<i8>::from(1..).raw_size(), Some(127));
         assert_eq!(Interval::<i8>::from(0..).raw_size(), Some(128));

common/src/gas_provider/property_tests/mod.rs

@@ -94,7 +94,7 @@ type Balance = u64;
 type Funds = u128;
 
 std::thread_local! {
-    static TOTAL_ISSUANCE: RefCell<Option<Balance>> = RefCell::new(None);
+    static TOTAL_ISSUANCE: RefCell<Option<Balance>> = const { RefCell::new(None) };
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -177,7 +177,7 @@ impl<T> From<ReservationKey> for GasNodeId<T, ReservationKey> {
 }
 
 std::thread_local! {
-    static GAS_TREE_NODES: RefCell<BTreeMap<Key, GasNode>> = RefCell::new(BTreeMap::new());
+    static GAS_TREE_NODES: RefCell<BTreeMap<Key, GasNode>> = const { RefCell::new(BTreeMap::new()) };
 }
 
 struct GasTreeNodesWrap;

examples/calc-hash/over-blocks/src/wasm.rs

@@ -1,5 +1,5 @@
 use crate::Method;
-use gstd::{exec, msg};
+use gstd::{exec, msg, prelude::*};
 use types::Package;
 
 #[no_mangle]
@@ -11,7 +11,7 @@ extern "C" fn init() {
 extern "C" fn handle() {
     let threshold = unsafe { state::THRESHOLD.expect("Threshold has not been set.") };
     let method = msg::load::<Method>().expect("Invalid program method.");
-    let registry = unsafe { &mut state::REGISTRY };
+    let registry = unsafe { &mut *ptr::addr_of_mut!(state::REGISTRY) };
 
     match method {
         Method::Start { expected, id, src } => {

examples/constructor/src/builder.rs

@@ -46,8 +46,6 @@ impl Calls {
         self
     }
 
-    // TODO #3452: remove this on next rust update
-    #[allow(clippy::useless_conversion)]
     pub fn add_from_iter(mut self, calls: impl Iterator<Item = Call>) -> Self {
         self.0.extend(calls.into_iter());
         self

examples/constructor/src/wasm.rs

@@ -7,7 +7,7 @@ static mut SCHEME: Option<Scheme> = None;
 fn process_fn<'a>(f: impl Fn(&'a Scheme) -> Option<&'a Vec<Call>>) {
     let scheme = unsafe { SCHEME.as_ref() }.expect("Should be set before access");
     let calls = f(scheme)
-        .map(Clone::clone)
+        .cloned()
         .unwrap_or_else(|| msg::load().expect("Failed to load payload"));
 
     let mut res = None;

examples/fungible-token/src/wasm.rs

@@ -170,10 +170,10 @@ extern "C" fn state() {
         decimals,
     } = state;
 
-    let balances = balances.into_iter().map(|(k, v)| (k, v)).collect();
+    let balances = balances.into_iter().collect();
     let allowances = allowances
         .into_iter()
-        .map(|(id, allowance)| (id, allowance.into_iter().map(|(k, v)| (k, v)).collect()))
+        .map(|(id, allowance)| (id, allowance.into_iter().collect()))
         .collect();
     let payload = IoFungibleToken {
         name,

examples/fungible-token/tests/benchmarks.rs

@@ -92,7 +92,7 @@ async fn stress_test() -> Result<()> {
     .encode();
 
     let (message_id, program_id, _hash) = api
-        .upload_program_bytes(WASM_BINARY.to_vec(), [137u8], init_msg, MAX_GAS_LIMIT, 0)
+        .upload_program_bytes(WASM_BINARY, [137u8], init_msg, MAX_GAS_LIMIT, 0)
         .await?;
 
     assert!(listener.message_processed(message_id).await?.succeed());
@@ -229,7 +229,7 @@ async fn stress_transfer() -> Result<()> {
 
     let salt: u8 = rng.gen();
     let (message_id, program_id, _hash) = api
-        .upload_program_bytes(WASM_BINARY.to_vec(), [salt], init_msg, MAX_GAS_LIMIT, 0)
+        .upload_program_bytes(WASM_BINARY, [salt], init_msg, MAX_GAS_LIMIT, 0)
         .await
         .unwrap();
 

examples/init-wait/src/wasm.rs

@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use gstd::{collections::BTreeMap, exec, msg, MessageId};
+use gstd::{collections::BTreeMap, exec, msg, prelude::*, MessageId};
 
 #[derive(PartialEq, Debug)]
 enum State {
@@ -40,7 +40,7 @@ extern "C" fn handle() {
 
 #[no_mangle]
 extern "C" fn init() {
-    let state = unsafe { &mut STATE };
+    let state = unsafe { &mut *ptr::addr_of_mut!(STATE) };
     match state {
         State::NotInited => {
             for k in 0..20 {

examples/new-meta/src/wasm.rs

@@ -24,10 +24,10 @@ extern "C" fn init() {
 extern "C" fn handle() {
     let message_in: MessageIn = msg::load().unwrap();
 
-    let res = unsafe { &WALLETS }
+    let res = unsafe { &*ptr::addr_of!(WALLETS) }
         .iter()
         .find(|w| w.id.decimal == message_in.id.decimal)
-        .map(Clone::clone);
+        .cloned();
 
     let message_out = MessageOut { res };
 

examples/node/src/wasm.rs

@@ -143,7 +143,7 @@ fn process(request: Request) -> Reply {
                     transition.query_list = state().sub_nodes.iter().cloned().collect();
                     let first_sub_node = *transition
                         .query_list
-                        .get(0)
+                        .first()
                         .expect("Checked above that sub_nodes is not empty; qed");
                     transition.last_sent_message_id =
                         msg::send(first_sub_node, request, 0).unwrap();
@@ -176,7 +176,7 @@ fn process(request: Request) -> Reply {
                 if let TransitionState::Ready = transition.state {
                     let first_sub_node = *transition
                         .query_list
-                        .get(0)
+                        .first()
                         .expect("Checked above that sub_nodes is not empty; qed");
 
                     transition.query_index = 0;

examples/reserve-gas/src/wasm.rs

@@ -62,7 +62,7 @@ extern "C" fn init() {
                 )
             };
         }
-        InitAction::Wait => match unsafe { &WAKE_STATE } {
+        InitAction::Wait => match unsafe { &*ptr::addr_of!(WAKE_STATE) } {
             WakeState::Initial => {
                 let _reservation = ReservationId::reserve(50_000, 10);
                 // to find message to reply to in test
@@ -152,7 +152,7 @@ extern "C" fn handle() {
             }
         }
         HandleAction::ConsumeReservationsFromList => {
-            let reservations = unsafe { mem::take(&mut RESERVATIONS) };
+            let reservations = unsafe { mem::take(&mut *ptr::addr_of_mut!(RESERVATIONS)) };
             for reservation_id in reservations {
                 msg::send_from_reservation(
                     reservation_id,

examples/signal-entry/src/wasm.rs

@@ -49,7 +49,7 @@ extern "C" fn init() {
 #[no_mangle]
 extern "C" fn handle() {
     unsafe { HANDLE_MSG = Some(msg::id()) };
-    let do_panic = unsafe { &mut DO_PANIC };
+    let do_panic = unsafe { &mut *ptr::addr_of_mut!(DO_PANIC) };
 
     let action: HandleAction = msg::load().unwrap();
     match action {
@@ -234,7 +234,7 @@ extern "C" fn handle() {
 
 #[no_mangle]
 extern "C" fn handle_signal() {
-    match unsafe { &HANDLE_SIGNAL_STATE } {
+    match unsafe { &*ptr::addr_of!(HANDLE_SIGNAL_STATE) } {
         HandleSignalState::Normal => {
             msg::send(unsafe { INITIATOR }, b"handle_signal", 0).unwrap();
             let signal_code = msg::signal_code()

examples/state-rollback/src/wasm.rs

@@ -25,7 +25,8 @@ extern "C" fn handle() {
     let payload = msg::load_bytes().expect("Failed to load payload");
 
     // Previous value
-    msg::send(msg::source(), unsafe { &PAYLOAD }, 0).expect("Failed to send message");
+    msg::send(msg::source(), unsafe { &*ptr::addr_of!(PAYLOAD) }, 0)
+        .expect("Failed to send message");
 
     let is_panic = payload == b"panic";
     let is_leave = payload == b"leave";
@@ -34,7 +35,7 @@ extern "C" fn handle() {
     unsafe { PAYLOAD = Some(payload) };
 
     // Newly set value
-    msg::reply(unsafe { &PAYLOAD }, 0).expect("Failed to send reply");
+    msg::reply(unsafe { &*ptr::addr_of!(PAYLOAD) }, 0).expect("Failed to send reply");
 
     // Stop execution with panic.
     is_panic.then(|| panic!());

examples/wait/src/wasm.rs

@@ -19,6 +19,7 @@
 // for panic/oom handlers
 extern crate gstd;
 
+use core::ptr;
 use gcore::{exec, msg, MessageId};
 
 static mut STATE: u32 = 0;
@@ -27,7 +28,7 @@ static mut MSG_ID_2: MessageId = MessageId::zero();
 
 #[no_mangle]
 extern "C" fn handle() {
-    let state = unsafe { &mut STATE };
+    let state = unsafe { &mut *ptr::addr_of_mut!(STATE) };
     gstd::debug!("{state}");
 
     match *state {

examples/waiter/src/wasm.rs

@@ -23,7 +23,7 @@ use crate::{
 use core::ops::{Deref, DerefMut};
 use futures::future;
 use gstd::{
-    exec, format, msg,
+    exec, format, msg, ptr,
     sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard},
 };
 
@@ -117,21 +117,24 @@ async fn main() {
             };
             let lock_guard = lock.await;
             process_mx_lock_continuation(
-                unsafe { &mut MUTEX_LOCK_GUARD },
+                unsafe { &mut *ptr::addr_of_mut!(MUTEX_LOCK_GUARD) },
                 lock_guard,
                 continuation,
             )
             .await;
         }
         Command::MxLockStaticAccess(subcommand) => {
-            process_lock_static_access_subcommand_mut(unsafe { &mut MUTEX_LOCK_GUARD }, subcommand);
+            process_lock_static_access_subcommand_mut(
+                unsafe { &mut *ptr::addr_of_mut!(MUTEX_LOCK_GUARD) },
+                subcommand,
+            );
         }
         Command::RwLock(lock_type, continuation) => {
             match lock_type {
                 RwLockType::Read => {
                     let lock_guard = unsafe { RW_LOCK.read().await };
                     process_rw_lock_continuation(
-                        unsafe { &mut R_LOCK_GUARD },
+                        unsafe { &mut *ptr::addr_of_mut!(R_LOCK_GUARD) },
                         lock_guard,
                         continuation,
                     )
@@ -140,7 +143,7 @@ async fn main() {
                 RwLockType::Write => {
                     let lock_guard = unsafe { RW_LOCK.write().await };
                     process_rw_lock_continuation(
-                        unsafe { &mut W_LOCK_GUARD },
+                        unsafe { &mut *ptr::addr_of_mut!(W_LOCK_GUARD) },
                         lock_guard,
                         continuation,
                     )
@@ -150,10 +153,16 @@ async fn main() {
         }
         Command::RwLockStaticAccess(lock_type, subcommand) => match lock_type {
             RwLockType::Read => {
-                process_lock_static_access_subcommand(unsafe { &mut R_LOCK_GUARD }, subcommand);
+                process_lock_static_access_subcommand(
+                    unsafe { &mut *ptr::addr_of_mut!(R_LOCK_GUARD) },
+                    subcommand,
+                );
             }
             RwLockType::Write => {
-                process_lock_static_access_subcommand_mut(unsafe { &mut W_LOCK_GUARD }, subcommand);
+                process_lock_static_access_subcommand_mut(
+                    unsafe { &mut *ptr::addr_of_mut!(W_LOCK_GUARD) },
+                    subcommand,
+                );
             }
         },
     }

gcli/tests/common/mod.rs

@@ -17,17 +17,12 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 //! Common utils for integration tests
-pub use self::{
-    args::Args,
-    node::{Convert, NodeExec},
-    result::{Error, Result},
-};
+pub use self::{args::Args, node::NodeExec, result::Result};
 use gear_core::ids::{CodeId, ProgramId};
 use gsdk::{
     ext::{sp_core::crypto::Ss58Codec, sp_runtime::AccountId32},
     testing::Node,
 };
-pub use scale_info::scale::Encode;
 use std::{
     iter::IntoIterator,
     process::{Command, Output},

gclient/src/api/listener/mod.rs

@@ -21,7 +21,6 @@ mod subscription;
 
 pub use gsdk::metadata::{gear::Event as GearEvent, Event};
 pub use iterator::*;
-pub use subscription::*;
 
 use crate::{Error, Result};
 use async_trait::async_trait;

gclient/src/api/storage/mod.rs

@@ -19,8 +19,6 @@
 pub(crate) mod account_id;
 mod block;
 
-pub use block::*;
-
 use super::{GearApi, Result};
 use crate::Error;
 use account_id::IntoAccountId32;

gclient/src/lib.rs

@@ -135,7 +135,7 @@ mod api;
 mod utils;
 mod ws;
 
-pub use api::{calls::*, error::*, listener::*, GearApi};
+pub use api::{error::*, listener::*, GearApi};
 pub use gsdk::metadata::errors;
 pub use utils::*;
 pub use ws::WSAddress;

gsdk/src/storage.rs

@@ -360,8 +360,7 @@ impl Api {
             ],
         );
 
-        let data: Option<(UserStoredMessage, Interval<u32>)> = self.fetch_storage(&addr).await.ok();
-        Ok(data.map(|(m, i)| (m, i)))
+        Ok(self.fetch_storage(&addr).await.ok())
     }
 
     /// Get all mailbox messages or for the provided `address`.

gsdk/src/testing/node.rs

@@ -78,7 +78,10 @@ impl Node {
             return Err(Error::EmptyStderr);
         };
 
-        for line in BufReader::new(stderr).lines().flatten() {
+        for line in BufReader::new(stderr)
+            .lines()
+            .map_while(|result| result.ok())
+        {
             if line.contains(log) {
                 return Ok(line);
             }
@@ -91,7 +94,7 @@ impl Node {
     pub fn print_logs(&mut self) {
         let stderr = self.process.stderr.as_mut();
         let reader = BufReader::new(stderr.expect("Unable to get stderr"));
-        for line in reader.lines().flatten() {
+        for line in reader.lines().map_while(|result| result.ok()) {
             println!("{line}");
         }
     }

gstd/src/async_runtime/signals.rs

@@ -89,7 +89,7 @@ impl WakeSignals {
         self.signals.contains_key(&reply_to)
     }
 
-    pub fn poll(&mut self, reply_to: MessageId, cx: &Context<'_>) -> ReplyPoll {
+    pub fn poll(&mut self, reply_to: MessageId, cx: &mut Context<'_>) -> ReplyPoll {
         match self.signals.remove(&reply_to) {
             None => ReplyPoll::None,
             Some(mut signal @ WakeSignal { payload: None, .. }) => {