workspace: Pin toolchain to rust version 1.93

Cargo.toml

@@ -24,7 +24,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-rust-version = "1.85"
+rust-version = "1.87"
 license = "MPL-2.0"
 edition = "2024"
 

consensus/CHANGELOG.md

@@ -10,7 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Update to edition 2024
-- Update MSRV to 1.85
+- Update MSRV to 1.87
 
 ### Fixed
 

consensus/src/execution_ctx.rs

@@ -424,25 +424,25 @@ impl<'a, T: Operations + 'static, DB: Database> ExecutionCtx<'a, T, DB> {
     ) {
         let step = StepName::Ratification.to_step(msg_iteration);
 
-        if let Some(committee) = self.iter_ctx.committees.get_committee(step) {
-            if self.am_member(committee) {
-                debug!(
-                    event = "Cast past vote",
-                    step = "Ratification",
-                    mode = "emergency",
-                    round = self.round_update.round,
-                    iter = msg_iteration
-                );
+        if let Some(committee) = self.iter_ctx.committees.get_committee(step)
+            && self.am_member(committee)
+        {
+            debug!(
+                event = "Cast past vote",
+                step = "Ratification",
+                mode = "emergency",
+                round = self.round_update.round,
+                iter = msg_iteration
+            );
 
-                // Should we collect our own vote?
-                let _msg = RatificationStep::try_vote(
-                    &self.round_update,
-                    msg_iteration,
-                    validation,
-                    self.outbound.clone(),
-                )
-                .await;
-            }
+            // Should we collect our own vote?
+            let _msg = RatificationStep::try_vote(
+                &self.round_update,
+                msg_iteration,
+                validation,
+                self.outbound.clone(),
+            )
+            .await;
         }
     }
 
@@ -587,17 +587,15 @@ impl<'a, T: Operations + 'static, DB: Database> ExecutionCtx<'a, T, DB> {
             // same round/step.
             Err(ConsensusError::FutureEvent) => {
                 const SRC: &str = "inbound future message";
-                if !same_prev_hash {
-                    if let Some(signer) = msg.get_signer() {
-                        if !self
-                            .provisioners
-                            .eligibles(msg.header.round)
-                            .any(|(p, _)| p == &signer)
-                        {
-                            log_msg("discarded msg (not eligible)", SRC, &msg);
-                            return None;
-                        }
-                    }
+                if !same_prev_hash
+                    && let Some(signer) = msg.get_signer()
+                    && !self
+                        .provisioners
+                        .eligibles(msg.header.round)
+                        .any(|(p, _)| p == &signer)
+                {
+                    log_msg("discarded msg (not eligible)", SRC, &msg);
+                    return None;
                 }
 
                 // We verify message signatures only for the next 10 round

consensus/src/validation/handler.rs

@@ -228,31 +228,31 @@ impl<D: Database> MsgHandler for ValidationHandler<D> {
         committee: &Committee,
         generator: Option<PublicKeyBytes>,
     ) -> Result<StepOutcome, ConsensusError> {
-        if is_emergency_iter(msg.header.iteration) {
-            if let Payload::ValidationQuorum(vq) = msg.payload {
-                if !vq.result.vote().is_valid() {
-                    return Err(ConsensusError::InvalidMsgType);
-                };
-
-                let vr = vq.result;
-
-                // Store ValidationResult
-                debug!(
-                  event = "Store ValidationResult",
-                  info = ?vq.header,
-                  src = "ValidationQuorum"
-                );
+        if is_emergency_iter(msg.header.iteration)
+            && let Payload::ValidationQuorum(vq) = msg.payload
+        {
+            if !vq.result.vote().is_valid() {
+                return Err(ConsensusError::InvalidMsgType);
+            };
 
-                self.db
-                    .lock()
-                    .await
-                    .store_validation_result(&vq.header, &vr)
-                    .await;
+            let vr = vq.result;
 
-                // Extract the ValidationResult and return it as msg
-                let vr_msg = vr.into();
-                return Ok(StepOutcome::Ready(vr_msg));
-            }
+            // Store ValidationResult
+            debug!(
+              event = "Store ValidationResult",
+              info = ?vq.header,
+              src = "ValidationQuorum"
+            );
+
+            self.db
+                .lock()
+                .await
+                .store_validation_result(&vq.header, &vr)
+                .await;
+
+            // Extract the ValidationResult and return it as msg
+            let vr_msg = vr.into();
+            return Ok(StepOutcome::Ready(vr_msg));
         }
 
         let p = Self::unwrap_msg(msg)?;

core/CHANGELOG.md

@@ -12,7 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Update to edition 2024
 - Replace nightly `cfg_eval`/`serde_as` with stable `serde(with)` attributes
 - Remove nightly `#![feature(cfg_eval)]` and `#![feature(const_fn_floating_point_arithmetic)]`
-- Update MSRV to 1.85
+- Update MSRV to 1.87
 
 ### Added
 

core/src/transfer.rs

@@ -507,10 +507,10 @@ impl Transaction {
         }
 
         let min_charge = self.blob_charge(gas_per_blob);
-        if let Some(min_charge) = min_charge {
-            if self.gas_limit() < min_charge {
-                return Err(TxPreconditionError::BlobLowLimit(min_charge));
-            }
+        if let Some(min_charge) = min_charge
+            && self.gas_limit() < min_charge
+        {
+            return Err(TxPreconditionError::BlobLowLimit(min_charge));
         }
         Ok(min_charge)
     }

core/src/transfer/moonlight.rs

@@ -137,10 +137,10 @@ impl Transaction {
         sender_sk: &AccountSecretKey,
         payload: Payload,
     ) -> Result<Self, Error> {
-        if let Some(TransactionData::Memo(memo)) = payload.data.as_ref() {
-            if memo.len() > MAX_MEMO_SIZE {
-                return Err(Error::MemoTooLarge(memo.len()));
-            }
+        if let Some(TransactionData::Memo(memo)) = payload.data.as_ref()
+            && memo.len() > MAX_MEMO_SIZE
+        {
+            return Err(Error::MemoTooLarge(memo.len()));
         }
 
         let digest = payload.signature_message();

core/src/transfer/phoenix.rs

@@ -127,10 +127,10 @@ impl Transaction {
     ) -> Result<Self, Error> {
         let data = data.map(Into::into);
 
-        if let Some(TransactionData::Memo(memo)) = data.as_ref() {
-            if memo.len() > MAX_MEMO_SIZE {
-                return Err(Error::MemoTooLarge(memo.len()));
-            }
+        if let Some(TransactionData::Memo(memo)) = data.as_ref()
+            && memo.len() > MAX_MEMO_SIZE
+        {
+            return Err(Error::MemoTooLarge(memo.len()));
         }
 
         let sender_pk = PublicKey::from(sender_sk);

data-drivers/data-driver/CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Update to edition 2024
+- Update MSRV to 1.87
 
 ## [0.3.1] - 2026-02-11
 

node-data/CHANGELOG.md

@@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Update to edition 2024
 - Replace `serde_as` with stable `serde(with)` attributes
-- Update MSRV to 1.85
+- Update MSRV to 1.87
 
 ## [1.4.0] - 2025-11-06
 

node/CHANGELOG.md

@@ -12,7 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Update to edition 2024
 - Replace `serde_as` with stable `serde(with)` attributes
 - Remove unused lifetime in `fetch_unfinalized_events_by_hash`
-- Update MSRV to 1.85
+- Update MSRV to 1.87
 
 ## [1.4.2] - 2025-12-13
 

node/src/archive/transformer.rs

@@ -239,12 +239,12 @@ fn record_flows(
                                 handle_inflow(moonlight_event.sender);
                             }
 
-                            if let Some((key, amt)) = refund {
-                                if amt > 0 {
-                                    // We rely on the fact, that refund only
-                                    // exists if different from sender
-                                    handle_inflow(key);
-                                }
+                            if let Some((key, amt)) = refund
+                                && amt > 0
+                            {
+                                // We rely on the fact, that refund only
+                                // exists if different from sender
+                                handle_inflow(key);
                             }
                         }
                         (Some(receiver), None) => {

node/src/chain.rs

@@ -187,18 +187,18 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution>
                             // from a peer only after explicit request (on demand).
                             match fsm.on_block_event(*blk, msg.metadata.clone()).await {
                                 Ok(res) => {
-                                    if let Some(accepted_blk) = res {
+                                    if let Some(accepted_blk) = res
+                                        && is_emergency_block(accepted_blk.header().iteration)
+                                    {
                                         // Repropagate Emergency Blocks
                                         // We already know it's valid because we accepted it
-                                        if is_emergency_block(accepted_blk.header().iteration){
-                                            // We build a new `msg` to avoid cloning `blk` when
-                                            // passing it to `on_block_event`.
-                                            // We copy the metadata to keep the original ray_id.
-                                            let mut eb_msg = Message::from(accepted_blk);
-                                            eb_msg.metadata = msg.metadata;
-                                            if let Err(e) = network.read().await.broadcast(&eb_msg).await {
-                                                warn!("Unable to re-broadcast Emergency Block: {e}");
-                                            }
+                                        // We build a new `msg` to avoid cloning `blk` when
+                                        // passing it to `on_block_event`.
+                                        // We copy the metadata to keep the original ray_id.
+                                        let mut eb_msg = Message::from(accepted_blk);
+                                        eb_msg.metadata = msg.metadata;
+                                        if let Err(e) = network.read().await.broadcast(&eb_msg).await {
+                                            warn!("Unable to re-broadcast Emergency Block: {e}");
                                         }
                                     }
                                 }
@@ -221,10 +221,10 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution>
                     // Handle quorum messages from Consensus layer.
                     // If the associated candidate block already exists,
                     // the winner block will be compiled and redirected to the Acceptor.
-                    if let Payload::Quorum(quorum) = &msg.payload {
-                      if let RatificationResult::Success(_) = quorum.att.result {
-                          fsm.on_success_quorum(quorum, msg.metadata.clone()).await;
-                      }
+                    if let Payload::Quorum(quorum) = &msg.payload
+                        && let RatificationResult::Success(_) = quorum.att.result
+                    {
+                        fsm.on_success_quorum(quorum, msg.metadata.clone()).await;
                     }
 
                     if let Payload::GetResource(res) = &msg.payload {

node/src/chain/consensus.rs

@@ -173,10 +173,10 @@ impl Task {
     }
 
     pub(crate) fn abort(&mut self) {
-        if let Some((_, cancel_chan)) = self.running_task.take() {
-            if cancel_chan.send(0).is_err() {
-                warn!("Unable to send cancel for abort")
-            };
+        if let Some((_, cancel_chan)) = self.running_task.take()
+            && cancel_chan.send(0).is_err()
+        {
+            warn!("Unable to send cancel for abort");
         }
     }
 

node/src/chain/fsm.rs

@@ -195,11 +195,10 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
         // unless it's an Emergency Blocks, which have no Attestation
         if !Self::is_block_attested(&blk)
             && !is_emergency_block(blk.header().iteration)
+            && let Err(err) = self.attach_blk_att(&mut blk)
         {
-            if let Err(err) = self.attach_blk_att(&mut blk) {
-                warn!(event = "block discarded", ?err);
-                return Ok(None);
-            }
+            warn!(event = "block discarded", ?err);
+            return Ok(None);
         }
 
         let fsm_res = match &mut self.curr {
@@ -364,12 +363,11 @@ impl<N: Network, DB: database::DB, VM: vm::VMExecution> SimpleFSM<N, DB, VM> {
             // Check if we already accepted this block
             if let Ok(blk_exists) =
                 db.read().await.view(|t| t.block_exists(&candidate))
+                && blk_exists
             {
-                if blk_exists {
-                    warn!("skipping Quorum for known block");
-                    return;
-                }
-            };
+                warn!("skipping Quorum for known block");
+                return;
+            }
 
             let quorum_blk = if quorum_height > tip_height + 1 {
                 // Quorum from future

node/src/chain/fsm/insync.rs

@@ -340,11 +340,11 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network> InSyncImpl<DB, VM, N> {
     }
 
     pub async fn on_heartbeat(&mut self) -> anyhow::Result<bool> {
-        if let Some(pre_sync) = &mut self.presync {
-            if pre_sync.expiry <= Instant::now() {
-                // Reset presync if it timed out
-                self.presync = None;
-            }
+        if let Some(pre_sync) = &mut self.presync
+            && pre_sync.expiry <= Instant::now()
+        {
+            // Reset presync if it timed out
+            self.presync = None;
         }
 
         Ok(false)

node/src/chain/fsm/outofsync.rs

@@ -344,27 +344,26 @@ impl<DB: database::DB, VM: vm::VMExecution, N: Network>
         }
 
         // If we almost dequeued all requested blocks (2/3)
-        if self.last_request < current_height + (MAX_BLOCKS_TO_REQUEST / 3) {
-            if let Some(last_request) = self.request_pool_missing_blocks().await
-            {
-                self.last_request = last_request
-            }
+        if self.last_request < current_height + (MAX_BLOCKS_TO_REQUEST / 3)
+            && let Some(last_request) = self.request_pool_missing_blocks().await
+        {
+            self.last_request = last_request;
         }
 
         // if the pool is full, check if the new block has higher priority
-        if pool_len >= MAX_POOL_BLOCKS_SIZE {
-            if let Some(entry) = self.pool.last_entry() {
-                let stored_height = *entry.key();
-                if stored_height > block_height {
-                    debug!(
-                        event = "block removed",
-                        block_height, stored_height, pool_len,
-                    );
-                    entry.remove();
-                } else {
-                    debug!(event = "block skipped", block_height, pool_len);
-                    return Ok(false);
-                }
+        if pool_len >= MAX_POOL_BLOCKS_SIZE
+            && let Some(entry) = self.pool.last_entry()
+        {
+            let stored_height = *entry.key();
+            if stored_height > block_height {
+                debug!(
+                    event = "block removed",
+                    block_height, stored_height, pool_len,
+                );
+                entry.remove();
+            } else {
+                debug!(event = "block skipped", block_height, pool_len);
+                return Ok(false);
             }
         }