Update PolkaVM to latest version

Cargo.toml

@@ -1179,10 +1179,10 @@ polkadot-subsystem-bench = { path = "polkadot/node/subsystem-bench" }
 polkadot-test-client = { path = "polkadot/node/test/client" }
 polkadot-test-runtime = { path = "polkadot/runtime/test-runtime" }
 polkadot-test-service = { path = "polkadot/node/test/service" }
-polkavm = { version = "0.31.0", default-features = false }
-polkavm-common = { version = "0.31.0", default-features = false }
-polkavm-derive = "0.31.0"
-polkavm-linker = "0.31.0"
+polkavm = { version = "0.33.0", default-features = false }
+polkavm-common = { version = "0.33.0", default-features = false }
+polkavm-derive = "0.33.0"
+polkavm-linker = "0.33.0"
 portpicker = { version = "0.1.1" }
 pretty_assertions = { version = "1.3.0" }
 primitive-types = { version = "0.13.1", default-features = false, features = [

prdoc/pr_11650.prdoc

@@ -0,0 +1,18 @@
+title: Update PolkaVM to latest version (0.31 → 0.33)
+
+doc:
+  - audience: [Runtime Dev, Node Dev]
+    description: |
+      Updates all PolkaVM dependencies from 0.31.0 to 0.33.0.
+
+crates:
+  - name: sp-wasm-interface
+    bump: major
+  - name: sc-executor-common
+    bump: major
+  - name: sc-executor-polkavm
+    bump: minor
+  - name: sc-executor-wasmtime
+    bump: patch
+  - name: pallet-revive
+    bump: major

substrate/client/executor/common/src/error.rs

@@ -129,8 +129,8 @@ pub enum WasmError {
 	#[error("Failure to erase the wasm memory: {0}")]
 	ErasingFailed(String),
 
-	#[error("Wasm code failed validation.")]
-	InvalidModule,
+	#[error("Code failed validation: {0}")]
+	InvalidModule(String),
 
 	#[error("Wasm code could not be deserialized.")]
 	CantDeserializeWasm,
@@ -162,6 +162,15 @@ impl From<polkavm::Error> for WasmError {
 	}
 }
 
+impl From<polkavm::CompileError> for WasmError {
+	fn from(error: polkavm::CompileError) -> Self {
+		match error {
+			polkavm::CompileError::ValidationFailed(msg) => WasmError::InvalidModule(msg),
+			polkavm::CompileError::Error(err) => WasmError::Other(err.to_string()),
+		}
+	}
+}
+
 impl From<polkavm::Error> for Error {
 	fn from(error: polkavm::Error) -> Self {
 		Error::Other(error.to_string())

substrate/client/executor/polkavm/src/lib.rs

@@ -134,7 +134,7 @@ struct Context<'r, 'a>(&'r mut polkavm::Caller<'a, ()>);
 
 impl<'r, 'a> FunctionContext for Context<'r, 'a> {
 	fn read_memory_into(
-		&self,
+		&mut self,
 		address: Pointer<u8>,
 		dest: &mut [u8],
 	) -> sp_wasm_interface::Result<()> {

substrate/client/executor/wasmtime/src/host.rs

@@ -75,7 +75,7 @@ impl<'a> HostContext<'a> {
 
 impl<'a> sp_wasm_interface::FunctionContext for HostContext<'a> {
 	fn read_memory_into(
-		&self,
+		&mut self,
 		address: Pointer<u8>,
 		dest: &mut [u8],
 	) -> sp_wasm_interface::Result<()> {

substrate/frame/revive/src/vm/pvm.rs

 polkavm-common = { workspace = true, features = ["alloc"] } 
 polkavm = { workspace = true } 
 polkavm-common = { workspace = true, features = ["alloc"] } 
@@ -58,7 +58,7 @@ pub trait Memory<T: Config> {
 	/// Returns `Err` if one of the following conditions occurs:
 	///
 	/// - requested buffer is not within the bounds of the sandbox memory.
-	fn read_into_buf(&self, ptr: u32, buf: &mut [u8]) -> Result<(), DispatchError>;
+	fn read_into_buf(&mut self, ptr: u32, buf: &mut [u8]) -> Result<(), DispatchError>;
 
 	/// Write the given buffer to the designated location in the sandbox memory.
 	///
@@ -86,40 +86,40 @@ pub trait Memory<T: Config> {
 	/// Returns `Err` if one of the following conditions occurs:
 	///
 	/// - requested buffer is not within the bounds of the sandbox memory.
-	fn read(&self, ptr: u32, len: u32) -> Result<Vec<u8>, DispatchError> {
+	fn read(&mut self, ptr: u32, len: u32) -> Result<Vec<u8>, DispatchError> {
 		let mut buf = vec![0u8; len as usize];
 		self.read_into_buf(ptr, buf.as_mut_slice())?;
 		Ok(buf)
 	}
 
 	/// Same as `read` but reads into a fixed size buffer.
-	fn read_array<const N: usize>(&self, ptr: u32) -> Result<[u8; N], DispatchError> {
+	fn read_array<const N: usize>(&mut self, ptr: u32) -> Result<[u8; N], DispatchError> {
 		let mut buf = [0u8; N];
 		self.read_into_buf(ptr, &mut buf)?;
 		Ok(buf)
 	}
 
 	/// Read a `u32` from the sandbox memory.
-	fn read_u32(&self, ptr: u32) -> Result<u32, DispatchError> {
+	fn read_u32(&mut self, ptr: u32) -> Result<u32, DispatchError> {
 		let buf: [u8; 4] = self.read_array(ptr)?;
 		Ok(u32::from_le_bytes(buf))
 	}
 
 	/// Read a `U256` from the sandbox memory.
-	fn read_u256(&self, ptr: u32) -> Result<U256, DispatchError> {
+	fn read_u256(&mut self, ptr: u32) -> Result<U256, DispatchError> {
 		let buf: [u8; 32] = self.read_array(ptr)?;
 		Ok(U256::from_little_endian(&buf))
 	}
 
 	/// Read a `H160` from the sandbox memory.
-	fn read_h160(&self, ptr: u32) -> Result<H160, DispatchError> {
+	fn read_h160(&mut self, ptr: u32) -> Result<H160, DispatchError> {
 		let mut buf = H160::default();
 		self.read_into_buf(ptr, buf.as_bytes_mut())?;
 		Ok(buf)
 	}
 
 	/// Read a `H256` from the sandbox memory.
-	fn read_h256(&self, ptr: u32) -> Result<H256, DispatchError> {
+	fn read_h256(&mut self, ptr: u32) -> Result<H256, DispatchError> {
 		let mut code_hash = H256::default();
 		self.read_into_buf(ptr, code_hash.as_bytes_mut())?;
 		Ok(code_hash)
@@ -146,7 +146,7 @@ pub trait PolkaVmInstance<T: Config>: Memory<T> {
 // in the streaming implementation while it could fail with a segfault in the copy implementation.
 #[cfg(feature = "runtime-benchmarks")]
 impl<T: Config> Memory<T> for [u8] {
-	fn read_into_buf(&self, ptr: u32, buf: &mut [u8]) -> Result<(), DispatchError> {
+	fn read_into_buf(&mut self, ptr: u32, buf: &mut [u8]) -> Result<(), DispatchError> {
 		let ptr = ptr as usize;
 		let bound_checked =
 			self.get(ptr..ptr + buf.len()).ok_or_else(|| Error::<T>::OutOfBounds)?;
@@ -170,7 +170,7 @@ impl<T: Config> Memory<T> for [u8] {
 }
 
 impl<T: Config> Memory<T> for polkavm::RawInstance {
-	fn read_into_buf(&self, ptr: u32, buf: &mut [u8]) -> Result<(), DispatchError> {
+	fn read_into_buf(&mut self, ptr: u32, buf: &mut [u8]) -> Result<(), DispatchError> {
 		self.read_memory_into(ptr, buf)
 			.map(|_| ())
 			.map_err(|_| Error::<T>::OutOfBounds.into())
@@ -451,7 +451,7 @@ impl<'a, E: Ext, M: ?Sized + Memory<E::T>> Runtime<'a, E, M> {
 		Ok(())
 	}
 
-	fn decode_key(&self, memory: &M, key_ptr: u32, key_len: u32) -> Result<Key, TrapReason> {
+	fn decode_key(&self, memory: &mut M, key_ptr: u32, key_len: u32) -> Result<Key, TrapReason> {
 		let res = match key_len {
 			SENTINEL => {
 				let mut buffer = [0u8; 32];
@@ -476,7 +476,7 @@ impl<'a, E: Ext, M: ?Sized + Memory<E::T>> Runtime<'a, E, M> {
 
 	fn set_storage(
 		&mut self,
-		memory: &M,
+		memory: &mut M,
 		flags: u32,
 		key_ptr: u32,
 		key_len: u32,
@@ -521,7 +521,7 @@ impl<'a, E: Ext, M: ?Sized + Memory<E::T>> Runtime<'a, E, M> {
 
 	fn clear_storage(
 		&mut self,
-		memory: &M,
+		memory: &mut M,
 		flags: u32,
 		key_ptr: u32,
 		key_len: u32,

substrate/primitives/wasm-interface/src/lib.rs

@@ -297,13 +297,13 @@ impl PartialEq for dyn Function {
 /// Context used by `Function` to interact with the allocator and the memory of the wasm instance.
 pub trait FunctionContext {
 	/// Read memory from `address` into a vector.
-	fn read_memory(&self, address: Pointer<u8>, size: WordSize) -> Result<Vec<u8>> {
+	fn read_memory(&mut self, address: Pointer<u8>, size: WordSize) -> Result<Vec<u8>> {
 		let mut vec = vec![0; size as usize];
 		self.read_memory_into(address, &mut vec)?;
 		Ok(vec)
 	}
 	/// Read memory into the given `dest` buffer from `address`.
-	fn read_memory_into(&self, address: Pointer<u8>, dest: &mut [u8]) -> Result<()>;
+	fn read_memory_into(&mut self, address: Pointer<u8>, dest: &mut [u8]) -> Result<()>;
 	/// Write the given data at `address` into the memory.
 	fn write_memory(&mut self, address: Pointer<u8>, data: &[u8]) -> Result<()>;
 	/// Allocate a memory instance of `size` bytes.