Update Wasmi to v0.32.0-beta.5

substrate/frame/contracts/Cargo.toml

@@ -29,7 +29,7 @@ serde = { version = "1", optional = true, features = ["derive"] }
 smallvec = { version = "1", default-features = false, features = [
 	"const_generics",
 ] }
-wasmi = { version = "0.31", default-features = false }
+wasmi = { version = "0.32.0-beta.5", default-features = false }
 impl-trait-for-tuples = "0.2"
 
 # Only used in benchmarking to generate contract code

substrate/frame/contracts/proc-macro/src/lib.rs

@@ -186,7 +186,7 @@ impl HostFnReturn {
 			Self::U64 => quote! { ::core::primitive::u64 },
 		};
 		quote! {
-			::core::result::Result<#ok, ::wasmi::core::Trap>
+			::core::result::Result<#ok, ::wasmi::Error>
 		}
 	}
 }
@@ -660,7 +660,7 @@ fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2)
 		let into_host = if expand_blocks {
 			quote! {
 				|reason| {
-					::wasmi::core::Trap::from(reason)
+					::wasmi::Error::host(reason)
 				}
 			}
 		} else {

substrate/frame/contracts/src/wasm/prepare.rs

@@ -33,8 +33,8 @@ use sp_runtime::{traits::Hash, DispatchError};
 #[cfg(any(test, feature = "runtime-benchmarks"))]
 use sp_std::prelude::Vec;
 use wasmi::{
-	core::ValueType as WasmiValueType, Config as WasmiConfig, Engine, ExternType,
-	FuelConsumptionMode, Module, StackLimits,
+	core::ValueType as WasmiValueType, Config as WasmiConfig, Engine, ExternType, Module,
+	StackLimits,
 };
 
 /// Imported memory must be located inside this module. The reason for hardcoding is that current
@@ -71,8 +71,7 @@ impl LoadedModule {
 			.wasm_extended_const(false)
 			.wasm_saturating_float_to_int(false)
 			.floats(matches!(determinism, Determinism::Relaxed))
-			.consume_fuel(true)
-			.fuel_consumption_mode(FuelConsumptionMode::Eager);
+			.consume_fuel(true);
 
 		if let Some(stack_limits) = stack_limits {
 			config.set_stack_limits(stack_limits);

substrate/frame/contracts/src/wasm/runtime.rs

@@ -441,49 +441,53 @@ impl<'a, E: Ext + 'a> Runtime<'a, E> {
 
 	/// Converts the sandbox result and the runtime state into the execution outcome.
 	pub fn to_execution_result(self, sandbox_result: Result<(), wasmi::Error>) -> ExecResult {
-		use wasmi::core::TrapCode::OutOfFuel;
+		use wasmi::{
+			core::TrapCode,
+			errors::{ErrorKind, FuelError},
+		};
 		use TrapReason::*;
 
-		match sandbox_result {
+		let Err(error) = sandbox_result else {
 			// Contract returned from main function -> no data was returned.
-			Ok(_) => Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }),
+			return Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
+		};
+		if let ErrorKind::Fuel(FuelError::OutOfFuel) = error.kind() {
 			// `OutOfGas` when host asks engine to consume more than left in the _store_.
 			// We should never get this case, as gas meter is being charged (and hence raises error)
 			// first.
-			Err(wasmi::Error::Store(_)) => Err(Error::<E::T>::OutOfGas.into()),
-			// Contract either trapped or some host function aborted the execution.
-			Err(wasmi::Error::Trap(trap)) => {
-				if let Some(OutOfFuel) = trap.trap_code() {
-					// `OutOfGas` during engine execution.
-					return Err(Error::<E::T>::OutOfGas.into())
-				}
-				// If we encoded a reason then it is some abort generated by a host function.
-				if let Some(reason) = &trap.downcast_ref::<TrapReason>() {
-					match &reason {
-						Return(ReturnData { flags, data }) => {
-							let flags = ReturnFlags::from_bits(*flags)
-								.ok_or(Error::<E::T>::InvalidCallFlags)?;
-							return Ok(ExecReturnValue { flags, data: data.to_vec() })
-						},
-						Termination =>
-							return Ok(ExecReturnValue {
-								flags: ReturnFlags::empty(),
-								data: Vec::new(),
-							}),
-						SupervisorError(error) => return Err((*error).into()),
-					}
-				}
+			return Err(Error::<E::T>::OutOfGas.into())
+		}
+		match error.as_trap_code() {
+			Some(TrapCode::OutOfFuel) => {
+				// `OutOfGas` during engine execution.
+				return Err(Error::<E::T>::OutOfGas.into())
+			},
+			Some(_trap_code) => {
 				// Otherwise the trap came from the contract itself.
-				Err(Error::<E::T>::ContractTrapped.into())
+				return Err(Error::<E::T>::ContractTrapped.into())
 			},
-			// Any other error is returned only if instantiation or linking failed (i.e.
-			// wasm binary tried to import a function that is not provided by the host).
-			// This shouldn't happen because validation process ought to reject such binaries.
-			//
-			// Because panics are really undesirable in the runtime code, we treat this as
-			// a trap for now. Eventually, we might want to revisit this.
-			Err(_) => Err(Error::<E::T>::CodeRejected.into()),
+			None => {},
+		}
+		// If we encoded a reason then it is some abort generated by a host function.
+		if let Some(reason) = &error.downcast_ref::<TrapReason>() {
+			match &reason {
+				Return(ReturnData { flags, data }) => {
+					let flags =
+						ReturnFlags::from_bits(*flags).ok_or(Error::<E::T>::InvalidCallFlags)?;
+					return Ok(ExecReturnValue { flags, data: data.to_vec() })
+				},
+				Termination =>
+					return Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }),
+				SupervisorError(error) => return Err((*error).into()),
+			}
 		}
+		// Any other error is returned only if instantiation or linking failed (i.e.
+		// wasm binary tried to import a function that is not provided by the host).
+		// This shouldn't happen because validation process ought to reject such binaries.
+		//
+		// Because panics are really undesirable in the runtime code, we treat this as
+		// a trap for now. Eventually, we might want to revisit this.
+		Err(Error::<E::T>::CodeRejected.into())
 	}
 
 	/// Get a mutable reference to the inner `Ext`.