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 = [

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<()> {
@@ -289,7 +289,8 @@ where
 	};
 
 	let module =
-		polkavm::Module::from_blob(&engine, &polkavm::ModuleConfig::default(), blob.clone())?;
+		polkavm::Module::from_blob(&engine, &polkavm::ModuleConfig::default(), blob.clone())
+			.map_err(|_| WasmError::InvalidModule)?;
 
 	let mut linker = polkavm::Linker::new();
 

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.