Update wasmer to 6.0

Author: chipshort

Cargo.lock

@@ -58,7 +58,7 @@ base64 = "0.22.0"
 bnum = "0.11.0"
 cosmwasm-core = { version = "2.2.0-rc.1", path = "../core" }
 cosmwasm-derive = { version = "2.2.0-rc.1", path = "../derive" }
-derive_more = { version = "=1.0.0-beta.6", default-features = false, features = [
+derive_more = { version = "1.0.0", default-features = false, features = [
     "debug",
 ] }
 hex = "0.4"

contracts/crypto-verify/Cargo.lock

@@ -50,7 +50,7 @@ cosmwasm-std = { version = "2.2.0-rc.1", path = "../std", default-features = fal
 ] }
 cosmwasm-crypto = { version = "2.2.0-rc.1", path = "../crypto" }
 cosmwasm-vm-derive = { version = "2.2.0-rc.1", path = "../vm-derive" }
-derive_more = { version = "=1.0.0-beta.6", default-features = false, features = [
+derive_more = { version = "1.0.0", default-features = false, features = [
     "debug",
 ] }
 hex = "0.4"
@@ -60,11 +60,11 @@ serde_json = "1.0.140"
 sha2 = "0.10.3"
 thiserror = "1.0.26"
 # We pin wasmer to a specific version because the layout of cached modules can change between patch versions.
-wasmer = { version = "=5.0.4", default-features = false, features = [
+wasmer = { version = "=6.0.0-beta.1", default-features = false, features = [
     "singlepass",
 ] }
-wasmer-middlewares = "=5.0.4"
-wasmer-types = "=5.0.4"
+wasmer-middlewares = "=6.0.0-beta.1"
+wasmer-types = "=6.0.0-beta.1"
 strum = { version = "0.26.2", default-features = false, features = ["derive"] }
 # For heap profiling. Only used in the "heap_profiling" example. This has to be a non-dev dependency
 # because cargo currently does not support optional dev-dependencies.

packages/std/Cargo.toml

@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 use thiserror::Error;
 
-use wasmer::{DeserializeError, Module, Target};
+use wasmer::{sys::Target, DeserializeError, Module};
 
 use cosmwasm_std::Checksum;
 
@@ -79,7 +79,7 @@ fn raw_module_version_discriminator() -> String {
     let mut hasher = Blake2b::<U5>::new();
 
     hasher.update(MODULE_SERIALIZATION_VERSION.as_bytes());
-    hasher.update(wasmer::VERSION.as_bytes());
+    hasher.update(wasmer_types::VERSION.as_bytes());
 
     for hash in hashes {
         hasher.update(hash);
@@ -414,18 +414,18 @@ mod tests {
 
     #[test]
     fn target_id_works() {
-        let triple = wasmer::Triple {
-            architecture: wasmer::Architecture::X86_64,
+        let triple = wasmer::sys::Triple {
+            architecture: wasmer::sys::Architecture::X86_64,
             vendor: target_lexicon::Vendor::Nintendo,
             operating_system: target_lexicon::OperatingSystem::Fuchsia,
             environment: target_lexicon::Environment::Gnu,
             binary_format: target_lexicon::BinaryFormat::Coff,
         };
-        let target = Target::new(triple.clone(), wasmer::CpuFeature::POPCNT.into());
+        let target = Target::new(triple.clone(), wasmer::sys::CpuFeature::POPCNT.into());
         let id = target_id(&target);
         assert_eq!(id, "x86_64-nintendo-fuchsia-gnu-coff-719EEF18");
         // Changing CPU features changes the hash part
-        let target = Target::new(triple, wasmer::CpuFeature::AVX512DQ.into());
+        let target = Target::new(triple, wasmer::sys::CpuFeature::AVX512DQ.into());
         let id = target_id(&target);
         assert_eq!(id, "x86_64-nintendo-fuchsia-gnu-coff-E3770FA3");
 
@@ -439,14 +439,14 @@ mod tests {
     #[test]
     fn modules_path_works() {
         let base = PathBuf::from("modules");
-        let triple = wasmer::Triple {
-            architecture: wasmer::Architecture::X86_64,
+        let triple = wasmer::sys::Triple {
+            architecture: wasmer::sys::Architecture::X86_64,
             vendor: target_lexicon::Vendor::Nintendo,
             operating_system: target_lexicon::OperatingSystem::Fuchsia,
             environment: target_lexicon::Environment::Gnu,
             binary_format: target_lexicon::BinaryFormat::Coff,
         };
-        let target = Target::new(triple, wasmer::CpuFeature::POPCNT.into());
+        let target = Target::new(triple, wasmer::sys::CpuFeature::POPCNT.into());
         let p = modules_path(&base, 17, &target);
         let discriminator = raw_module_version_discriminator();
 

packages/vm/Cargo.toml

@@ -126,9 +126,12 @@ impl<'a> ParsedWasm<'a> {
                                     this.max_func_results =
                                         core::cmp::max(ft.results().len(), this.max_func_results);
                                 }
-                                CompositeInnerType::Array(_) | CompositeInnerType::Struct(_) => {
-                                    // ignoring these for now, as they are only available with the GC
-                                    // proposal and we explicitly disabled that above
+                                CompositeInnerType::Array(_)
+                                | CompositeInnerType::Struct(_)
+                                | CompositeInnerType::Cont(_) => {
+                                    // ignoring these for now, as they are only available with the
+                                    // GC / stack switching proposal and we explicitly disabled
+                                    // that above
                                 }
                             }
                         }

packages/vm/src/modules/file_system_cache.rs

@@ -1,9 +1,7 @@
 use cosmwasm_vm_derive::hash_function;
 use std::sync::Arc;
-use wasmer::NativeEngineExt;
-use wasmer::{
-    sys::BaseTunables, wasmparser::Operator, CompilerConfig, Engine, Pages, Target, WASM_PAGE_SIZE,
-};
+use wasmer::sys::{engine::NativeEngineExt, BaseTunables, CompilerConfig, Target};
+use wasmer::{wasmparser::Operator, Engine, Pages, WASM_PAGE_SIZE};
 use wasmer_middlewares::metering::{is_accounting, Metering};
 
 use crate::size::Size;
@@ -47,7 +45,7 @@ fn cost(operator: &Operator) -> u64 {
 
 /// Creates a compiler config using Singlepass
 pub fn make_compiler_config() -> impl CompilerConfig + Into<Engine> {
-    wasmer::Singlepass::new()
+    wasmer::sys::Singlepass::new()
 }
 
 /// Creates an engine without a compiler.

packages/vm/src/parsed_wasm.rs

@@ -1,7 +1,7 @@
 use wasmer::wasmparser::Operator;
 use wasmer::{
-    FunctionMiddleware, LocalFunctionIndex, MiddlewareError, MiddlewareReaderState,
-    ModuleMiddleware,
+    sys::{FunctionMiddleware, MiddlewareError, MiddlewareReaderState, ModuleMiddleware},
+    LocalFunctionIndex,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -112,7 +112,7 @@ impl FunctionMiddleware for FunctionGatekeeper {
         }
         /// Matches on the given operator and calls the corresponding handler function.
         macro_rules! gatekeep {
-            ($( @$proposal:ident $op:ident $({ $($payload:tt)* })? => $visit:ident)*) => {{
+            ($( @$proposal:ident $op:ident $({ $($payload:tt)* })? => $visit:ident ($($ann:tt)*))*) => {{
                 use wasmer::wasmparser::Operator::*;
 
                 let mut proposal_validator = ProposalValidator {
@@ -126,7 +126,8 @@ impl FunctionMiddleware for FunctionGatekeeper {
                         match_op!($op $({ $($payload)* })?) => {
                             proposal_validator.$proposal(operator)
                         }
-                    )*
+                    )*,
+                    _ => unreachable!(), // required because `Operator` enum is non-exhaustive
                 }
             }}
         }
@@ -366,14 +367,30 @@ impl<'a, 'b> ProposalValidator<'a, 'b> {
         );
         Err(MiddlewareError::new(MIDDLEWARE_NAME, msg))
     }
+
+    #[inline]
+    fn stack_switching(&'b mut self, operator: Operator<'a>) -> Result<(), MiddlewareError> {
+        let msg = format!(
+            "Stack switching operation detected: {operator:?}. Stack switching is not supported."
+        );
+        Err(MiddlewareError::new(MIDDLEWARE_NAME, msg))
+    }
+
+    #[inline]
+    fn wide_arithmetic(&'b mut self, operator: Operator<'a>) -> Result<(), MiddlewareError> {
+        let msg = format!(
+            "Stack switching operation detected: {operator:?}. Stack switching is not supported."
+        );
+        Err(MiddlewareError::new(MIDDLEWARE_NAME, msg))
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::wasm_backend::make_compiler_config;
     use std::sync::Arc;
-    use wasmer::{CompilerConfig, Module, Store};
+    use wasmer::{sys::CompilerConfig, Module, Store};
 
     #[test]
     fn valid_wasm_instance_sanity() {

packages/vm/src/wasm_backend/engine.rs

@@ -1,11 +1,14 @@
 use std::ptr::NonNull;
 
 use wasmer::{
-    vm::{
-        MemoryError, MemoryStyle, TableStyle, VMMemory, VMMemoryDefinition, VMTable,
-        VMTableDefinition,
+    sys::{
+        vm::{
+            MemoryError, MemoryStyle, TableStyle, VMMemory, VMMemoryDefinition, VMTable,
+            VMTableDefinition,
+        },
+        Tunables,
     },
-    MemoryType, Pages, TableType, Tunables,
+    MemoryType, Pages, TableType,
 };
 
 /// A custom tunables that allows you to set a memory limit.
@@ -128,7 +131,7 @@ impl<T: Tunables> Tunables for LimitingTunables<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use wasmer::{sys::BaseTunables, Target};
+    use wasmer::sys::{BaseTunables, Target};
 
     #[test]
     fn adjust_memory_works() {