chore: update rust to 1.81 (#1587)

Stebalien · rvagg · web-flow · commit fd6cb223933a · 2025-01-21T16:32:21.000Z
* chore: update rust to 1.82 And explicitly disable features we don't support. * fix lint errors * fix condition * undo dead code removal * improve precompile failure logging This gets rid of the clippy warning, and will make actor debug logs a bit more readable. * downgrade to 1.81.0 Rust 1.81.0 introduces some interesting breaking changes for wasm codegen and I'd rather not deal with those now. See the compatibility notes section of https://github.com/rust-lang/rust/releases/tag/1.82.0. * update lockfile --------- Co-authored-by: Rod Vagg <rod@vagg.org>
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -8,5 +8,10 @@ rustflags = [
 rustflags = [
     "-Ctarget-feature=+bulk-memory",
     "-Ctarget-feature=+crt-static",
+    "-Ctarget-feature=+mutable-globals",
+    "-Ctarget-feature=+sign-ext",
+    "-Ctarget-feature=-reference-types",
+    "-Ctarget-feature=-multivalue",
+    "-Ctarget-feature=-atomics",
     "-Clink-arg=--export-table",
 ]
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/actors/evm/Cargo.toml b/actors/evm/Cargo.toml
@@ -32,6 +32,7 @@ fil_actors_evm_shared = { workspace = true }
 hex = { workspace = true }
 hex-literal = { workspace = true }
 substrate-bn = { workspace = true }
+thiserror = { workspace = true }
 
 [dev-dependencies]
 hex = { workspace = true, features = ["serde"] }
diff --git a/actors/evm/shared/src/address.rs b/actors/evm/shared/src/address.rs
@@ -19,12 +19,19 @@ impl From<U256> for EthAddress {
     }
 }
 
-impl std::fmt::Debug for EthAddress {
+impl std::fmt::Display for EthAddress {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("0x")?;
         f.write_str(&hex::encode(self.0))
     }
 }
 
+impl std::fmt::Debug for EthAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self)
+    }
+}
+
 impl From<EthAddress> for Address {
     fn from(addr: EthAddress) -> Self {
         From::from(&addr)
diff --git a/actors/evm/src/interpreter/instructions/call.rs b/actors/evm/src/interpreter/instructions/call.rs
@@ -191,7 +191,7 @@ pub fn call_generic<RT: Runtime>(
             match precompiles::Precompiles::call_precompile(system, &dst, input_data, context) {
                 Ok(return_data) => (1, return_data),
                 Err(err) => {
-                    log::warn!(target: "evm", "Precompile failed: error {:?}", err);
+                    log::warn!(target: "evm", "call to precompile {} failed: {}", &dst, err);
                     // precompile failed, exit with reverted and no output
                     (0, vec![])
                 }
@@ -291,8 +291,8 @@ pub fn call_generic<RT: Runtime>(
                     // this is how the EVM behaves.
                     ContractType::Account | ContractType::NotFound => Ok(None),
                     // If we're calling a "native" actor, always revert.
-                    ContractType::Native(_) => {
-                        log::info!("attempted to delegatecall a native actor at {dst:?}");
+                    ContractType::Native(cid) => {
+                        log::info!("attempted to delegatecall a native actor {cid} at {dst:?}");
                         Err(None)
                     }
                     ContractType::Precompile => {
diff --git a/actors/evm/src/interpreter/precompiles/mod.rs b/actors/evm/src/interpreter/precompiles/mod.rs
@@ -4,6 +4,7 @@ use fil_actors_evm_shared::{address::EthAddress, uints::U256};
 use fil_actors_runtime::{runtime::Runtime, ActorError};
 use fvm_shared::{address::Address, econ::TokenAmount};
 use substrate_bn::{CurveError, FieldError, GroupError};
+use thiserror::Error;
 
 use crate::reader::OverflowError;
 
@@ -111,15 +112,21 @@ impl<RT: Runtime> Precompiles<RT> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum PrecompileError {
     // EVM precompile errors
+    #[error("EC curve error in data passed to precompile: {0:?}")]
     EcErr(CurveError),
+    #[error("incorrect input size to precompile")]
     IncorrectInputSize,
     // FVM precompile errors
+    #[error("invalid input to precompile")]
     InvalidInput,
+    #[error("calling convention forbidden for precompile")]
     CallForbidden,
+    #[error("transfering funds to precompile failed")]
     TransferFailed,
+    #[error("internal evm error when calling precompile: {0}")]
     VMError(ActorError),
 }
 
diff --git a/actors/init/tests/init_actor_test.rs b/actors/init/tests/init_actor_test.rs
@@ -435,11 +435,7 @@ fn construct_and_verify(rt: &MockRuntime) {
     check_state(rt);
 }
 
-fn exec_and_verify<S: Serialize>(
-    rt: &MockRuntime,
-    code_id: Cid,
-    params: &S,
-) -> Result<ExecReturn, ActorError>
+fn exec_and_verify<S>(rt: &MockRuntime, code_id: Cid, params: &S) -> Result<ExecReturn, ActorError>
 where
     S: Serialize,
 {
@@ -455,7 +451,7 @@ where
     ret.and_then(|v| v.unwrap().deserialize().map_err(|e| e.into()))
 }
 
-fn exec4_and_verify<S: Serialize>(
+fn exec4_and_verify<S>(
     rt: &MockRuntime,
     namespace: ActorID,
     subaddr: &[u8],
diff --git a/actors/market/src/testing.rs b/actors/market/src/testing.rs
@@ -167,7 +167,7 @@ pub fn check_state_invariants<BS: Blockstore>(
                 let deal_id: u64 = u64::decode_var(key.0.as_slice()).unwrap().0;
 
                 acc.require(
-                    proposal_stats.get(&deal_id).is_some(),
+                    proposal_stats.contains_key(&deal_id),
                     format!("pending deal allocation {} not found in proposals", deal_id),
                 );
 
diff --git a/actors/market/tests/harness.rs b/actors/market/tests/harness.rs
@@ -767,7 +767,7 @@ pub fn publish_deals(
         if deal.verified_deal {
             // Expect query for the client's datacap balance, just once per client.
             let client_id = deal.client.id().unwrap();
-            if client_verified_deals.get(&client_id).is_none() {
+            if !client_verified_deals.contains_key(&client_id) {
                 rt.expect_send_simple(
                     DATACAP_TOKEN_ACTOR_ADDR,
                     ext::datacap::BALANCE_OF_METHOD,
diff --git a/actors/market/tests/publish_storage_deals_failures.rs b/actors/market/tests/publish_storage_deals_failures.rs
@@ -392,7 +392,7 @@ fn fail_when_deals_have_different_providers() {
         .deserialize()
         .unwrap();
 
-    let valid: Vec<u64> = psd_ret.valid_deals.bounded_iter(std::u64::MAX).unwrap().collect();
+    let valid: Vec<u64> = psd_ret.valid_deals.bounded_iter(u64::MAX).unwrap().collect();
     assert_eq!(vec![0], valid);
 
     rt.verify();
diff --git a/actors/miner/tests/sector_map_test.rs b/actors/miner/tests/sector_map_test.rs
@@ -55,7 +55,7 @@ fn create_deadline_sector_map(
 }
 
 fn create_bitfield_sequence(start: u64, end: u64) -> BitField {
-    let ranges = vec![Range { start, end }];
+    let ranges = [Range { start, end }];
     let ranges = Ranges::new(ranges.iter().cloned());
     BitField::from_ranges(ranges)
 }
diff --git a/actors/miner/tests/sector_number_allocation.rs b/actors/miner/tests/sector_number_allocation.rs
@@ -89,7 +89,7 @@ mod sector_number_allocation {
         // Allocate widely-spaced numbers to consume the run-length encoded bytes quickly,
         // until the limit is reached.
         let mut limit_reached = false;
-        for i in 0..std::u64::MAX {
+        for i in 0..u64::MAX {
             let (number, _) = (i + 1).overflowing_shl(50);
             let res = h.allocate_sector_numbers(&[number]);
             if res.is_err() {
diff --git a/actors/paych/src/types.rs b/actors/paych/src/types.rs
@@ -13,7 +13,7 @@ use fvm_shared::MethodNum;
 use super::Merge;
 
 /// Maximum number of lanes in a channel
-pub const MAX_LANE: u64 = std::i64::MAX as u64;
+pub const MAX_LANE: u64 = i64::MAX as u64;
 
 pub const SETTLE_DELAY: ChainEpoch = EPOCHS_IN_HOUR * 12;
 
diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml
@@ -86,6 +86,8 @@ short-precommit = []
 min-power-2k = []
 # Lower the minimum power requirement to 2g
 min-power-2g = []
+# Lower the minimum power requirement to 32g
+min-power-32g = []
 
 # no collateral for deals (for testing)
 no-provider-deal-collateral = []
diff --git a/runtime/src/runtime/fvm.rs b/runtime/src/runtime/fvm.rs
@@ -573,8 +573,8 @@ where
 /// 2.  Obtains the method number for the invocation.
 /// 3.  Creates an FVM runtime shim.
 /// 4.  Invokes the target method.
-/// 5a. In case of error, aborts the execution with the emitted exit code, or
-/// 5b. In case of success, stores the return data as a block and returns the latter.
+/// 5. (a) In case of error, aborts the execution with the emitted exit code, or
+/// 5. (b) In case of success, stores the return data as a block and returns the latter.
 pub fn trampoline<C: ActorCode>(params: u32) -> u32 {
     init_logging(C::name());
 
diff --git a/runtime/src/runtime/mod.rs b/runtime/src/runtime/mod.rs
@@ -227,6 +227,7 @@ pub trait Runtime: Primitives + RuntimePolicy {
     /// The circulating supply is the sum of:
     /// - rewards emitted by the reward actor,
     /// - funds vested from lock-ups in the genesis state,
+    ///
     /// less the sum of:
     /// - funds burnt,
     /// - pledge collateral locked in storage miner actors (recorded in the storage power actor)
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "1.76.0"
+channel = "1.81.0"
 components = ["clippy", "llvm-tools-preview", "rustfmt"]
 targets = ["wasm32-unknown-unknown"]
diff --git a/vm_api/src/lib.rs b/vm_api/src/lib.rs
@@ -190,6 +190,7 @@ pub trait Primitives {
     /// - first header is of the same or lower epoch as the second
     /// - at least one of the headers appears in the current chain at or after epoch `earliest`
     /// - the headers provide evidence of a fault (see the spec for the different fault types).
+    ///
     /// The parameters are all serialized block headers. The third "extra" parameter is consulted only for
     /// the "parent grinding fault", in which case it must be the sibling of h1 (same parent tipset) and one of the
     /// blocks in the parent of h2 (i.e. h2's grandparent).

Original file line number	Diff line number	Diff line change
`@@ -19,12 +19,19 @@ impl From<U256> for EthAddress {`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`-impl std::fmt::Debug for EthAddress {`
	`22`	`+impl std::fmt::Display for EthAddress {`
`23`	`23`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
	`24`	`+ f.write_str("0x")?;`
`24`	`25`	`f.write_str(&hex::encode(self.0))`
`25`	`26`	`}`
`26`	`27`	`}`
`27`	`28`
	`29`	`+impl std::fmt::Debug for EthAddress {`
	`30`	`+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
	`31`	`+ write!(f, "{}", self)`
	`32`	`+ }`
	`33`	`+}`
	`34`	`+`
`28`	`35`	`impl From<EthAddress> for Address {`
`29`	`36`	`fn from(addr: EthAddress) -> Self {`
`30`	`37`	`From::from(&addr)`
Original file line number	Diff line number	Diff line change
`@@ -435,11 +435,7 @@ fn construct_and_verify(rt: &MockRuntime) {`
`435`	`435`	`check_state(rt);`
`436`	`436`	`}`
`437`	`437`
`438`		`-fn exec_and_verify<S: Serialize>(`
`439`		`- rt: &MockRuntime,`
`440`		`- code_id: Cid,`
`441`		`- params: &S,`
`442`		`-) -> Result<ExecReturn, ActorError>`
	`438`	`+fn exec_and_verify<S>(rt: &MockRuntime, code_id: Cid, params: &S) -> Result<ExecReturn, ActorError>`
`443`	`439`	`where`
`444`	`440`	`S: Serialize,`
`445`	`441`	`{`
`@@ -455,7 +451,7 @@ where`
`455`	`451`	`ret.and_then(\|v\| v.unwrap().deserialize().map_err(\|e\| e.into()))`
`456`	`452`	`}`
`457`	`453`
`458`		`-fn exec4_and_verify<S: Serialize>(`
	`454`	`+fn exec4_and_verify<S>(`
`459`	`455`	`rt: &MockRuntime,`
`460`	`456`	`namespace: ActorID,`
`461`	`457`	`subaddr: &[u8],`