chore: update proofs dependency and rust toolchain (#2265)

* chore: update proofs dependency and rust toolchain

* rm dead hash mod

Author: LesnyRumcajs

.github/workflows/deny.yml

@@ -15,4 +15,4 @@ jobs:
     - uses: actions/checkout@v4
     - uses: EmbarkStudios/cargo-deny-action@v2
       with:
-        rust-version: "1.81.0"
+        rust-version: "1.94.0"

Cargo.lock

@@ -182,21 +182,21 @@ where
     where
         K: Kernel<CallManager = Self>,
     {
-        if self.machine.context().tracing {
-            if let Entrypoint::Invoke(method) = &entrypoint {
-                self.trace(ExecutionEvent::Call {
-                    from,
-                    to,
-                    method: *method,
-                    params: params.as_ref().map(Into::into),
-                    value: value.clone(),
-                    gas_limit: std::cmp::min(
-                        gas_limit.unwrap_or(Gas::from_milligas(u64::MAX)).round_up(),
-                        self.gas_tracker.gas_available().round_up(),
-                    ),
-                    read_only,
-                });
-            }
+        if self.machine.context().tracing
+            && let Entrypoint::Invoke(method) = &entrypoint
+        {
+            self.trace(ExecutionEvent::Call {
+                from,
+                to,
+                method: *method,
+                params: params.as_ref().map(Into::into),
+                value: value.clone(),
+                gas_limit: std::cmp::min(
+                    gas_limit.unwrap_or(Gas::from_milligas(u64::MAX)).round_up(),
+                    self.gas_tracker.gas_available().round_up(),
+                ),
+                read_only,
+            });
         }
 
         // If a specific gas limit has been requested, push a new limit into the gas tracker.
@@ -897,14 +897,13 @@ where
                 .ok()
                 .and_then(|r| r.value.as_ref())
                 .map(|v| (v.size(), v.links().len()))
-            {
-                if let Err(e) = cm.charge_gas(cm.price_list().on_method_return(
+                && let Err(e) = cm.charge_gas(cm.price_list().on_method_return(
                     cm.call_stack_depth,
                     ret_size,
                     link_count,
-                )) {
-                    ret = Err(e);
-                }
+                ))
+            {
+                ret = Err(e);
             }
 
             // Log the results if tracing is enabled.

fvm/src/call_manager/default.rs

@@ -128,7 +128,9 @@ fn wasmtime_config(ec: &EngineConfig) -> anyhow::Result<wasmtime::Config> {
 
     let instance_count = ec.instance_pool_size();
     let instance_memory_maximum_size = ec.max_inst_memory_bytes;
-    if instance_memory_maximum_size % wasmtime_environ::Memory::DEFAULT_PAGE_SIZE as u64 != 0 {
+    if !instance_memory_maximum_size
+        .is_multiple_of(wasmtime_environ::Memory::DEFAULT_PAGE_SIZE as u64)
+    {
         return Err(anyhow!(
             "requested memory limit {} not a multiple of the WASM_PAGE_SIZE {}",
             instance_memory_maximum_size,

fvm/src/engine/mod.rs

@@ -282,7 +282,7 @@ impl GasTracker {
 #[inline]
 pub(crate) const fn milligas_to_gas(milligas: u64, round_up: bool) -> u64 {
     let mut div_result = milligas / MILLIGAS_PRECISION;
-    if round_up && milligas % MILLIGAS_PRECISION != 0 {
+    if round_up && !milligas.is_multiple_of(MILLIGAS_PRECISION) {
         div_result = div_result.saturating_add(1);
     }
     div_result

fvm/src/gas/mod.rs

@@ -94,7 +94,7 @@ impl Memory {
     pub fn try_chunks<const S: usize>(&self, offset: u32, len: u32) -> Result<&[[u8; S]]> {
         let num_chunks = {
             let len = len as usize;
-            if len % S != 0 {
+            if !len.is_multiple_of(S) {
                 return Err(syscall_error!(
                     IllegalArgument;
                     "buffer length {len} is not divisible by chunk len {S}"

fvm/src/syscalls/context.rs

@@ -353,12 +353,11 @@ where
                                 node::Link::Dirty(n) => (None, Either::Borrowed(n.borrow())),
                             };
 
-                            if let Some(prev_cid) = &prev_cid {
-                                if let Some(curr_cid) = &curr_cid {
-                                    if prev_cid == curr_cid {
-                                        continue;
-                                    }
-                                }
+                            if let Some(prev_cid) = &prev_cid
+                                && let Some(curr_cid) = &curr_cid
+                                && prev_cid == curr_cid
+                            {
+                                continue;
                             }
 
                             let prev_sub_ctx = NodeContext {

ipld/amt/src/diff.rs

@@ -333,13 +333,10 @@ where
 
     fn set_leaf(&mut self, i: u64, val: V) -> Option<V> {
         match self {
-            Node::Leaf { vals } => {
-                let prev = std::mem::replace(
-                    vals.get_mut(usize::try_from(i).unwrap()).unwrap(),
-                    Some(val),
-                );
-                prev
-            }
+            Node::Leaf { vals } => vals
+                .get_mut(usize::try_from(i).unwrap())
+                .unwrap()
+                .replace(val),
             Node::Link { .. } => panic!("set_leaf should never be called on a shard of links"),
         }
     }

ipld/amt/src/node.rs

@@ -14,22 +14,14 @@ impl RangeSize for Range<u64> {
     type Idx = u64;
 
     fn size(&self) -> Self::Idx {
-        if self.end <= self.start {
-            0
-        } else {
-            self.end - self.start
-        }
+        self.end.saturating_sub(self.start)
     }
 }
 
 impl RangeSize for Range<u32> {
     type Idx = u32;
 
     fn size(&self) -> Self::Idx {
-        if self.end <= self.start {
-            0
-        } else {
-            self.end - self.start
-        }
+        self.end.saturating_sub(self.start)
     }
 }

ipld/bitfield/src/range.rs

@@ -144,10 +144,10 @@ where
         // Read node -> cid, bytes
         match read_node(&mut self.reader) {
             Ok(Some(block)) => {
-                if self.validate {
-                    if let Err(e) = block.validate() {
-                        return Some(Err(e));
-                    }
+                if self.validate
+                    && let Err(e) = block.validate()
+                {
+                    return Some(Err(e));
                 }
                 Some(Ok(block))
             }