contracts: add encoded events to ContractResult

frame/contracts/primitives/src/lib.rs

@@ -33,7 +33,7 @@ use sp_weights::Weight;
 ///
 /// It contains the execution result together with some auxiliary information.
 #[derive(Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
-pub struct ContractResult<R, Balance, Event> {
+pub struct ContractResult<R, Balance> {
 	/// How much weight was consumed during execution.
 	pub gas_consumed: Weight,
 	/// How much weight is required as gas limit in order to execute this call.
@@ -71,16 +71,16 @@ pub struct ContractResult<R, Balance, Event> {
 	pub debug_message: Vec<u8>,
 	/// The execution result of the wasm code.
 	pub result: R,
-	pub events: Option<Vec<Event>>,
+	pub events: Option<Vec<Vec<u8>>>,
 }
 
 /// Result type of a `bare_call` call.
-pub type ContractExecResult<Balance, Event> =
-	ContractResult<Result<ExecReturnValue, DispatchError>, Balance, Event>;
+pub type ContractExecResult<Balance> =
+	ContractResult<Result<ExecReturnValue, DispatchError>, Balance>;
 
 /// Result type of a `bare_instantiate` call.
 pub type ContractInstantiateResult<AccountId, Balance> =
-	ContractResult<Result<InstantiateReturnValue<AccountId>, DispatchError>, Balance, ()>;
+	ContractResult<Result<InstantiateReturnValue<AccountId>, DispatchError>, Balance>;
 
 /// Result type of a `bare_code_upload` call.
 pub type CodeUploadResult<CodeHash, Balance> =

frame/contracts/src/lib.rs

@@ -118,7 +118,7 @@ use frame_support::{
 	weights::{OldWeight, Weight},
 	BoundedVec, WeakBoundedVec,
 };
-use frame_system::{EventRecord, Pallet as System};
+use frame_system::Pallet as System;
 use pallet_contracts_primitives::{
 	Code, CodeUploadResult, CodeUploadReturnValue, ContractAccessError, ContractExecResult,
 	ContractInstantiateResult, ExecReturnValue, GetStorageResult, InstantiateReturnValue,
@@ -1167,7 +1167,7 @@ impl<T: Config> Pallet<T> {
 		data: Vec<u8>,
 		debug: bool,
 		determinism: Determinism,
-	) -> ContractExecResult<BalanceOf<T>, EventRecord<<T as pallet::Config>::RuntimeEvent, T>> {
+	) -> ContractExecResult<BalanceOf<T>> {
 		let mut debug_message = if debug { Some(DebugBufferVec::<T>::default()) } else { None };
 		let common = CommonInput {
 			origin,
@@ -1178,15 +1178,18 @@ impl<T: Config> Pallet<T> {
 			debug_message: debug_message.as_mut(),
 		};
 		let output = CallInput::<T> { dest, determinism }.run_guarded(common);
+		// We are good to call System::events() from the runtime API (i.e offchain).
+		// Even though it says it should only be used in tests, it is actually not allowed to be
+		// read on-chain cause it will put all the Events emitted in the block so far into the PoV.
+		let events: Vec<Vec<u8>> =
+			System::<T>::events().iter().map(|e| e.clone().event.encode()).collect(); // todo: should determinism::Relaxed be checked here?
 		ContractExecResult {
 			result: output.result.map_err(|r| r.error),
 			gas_consumed: output.gas_meter.gas_consumed(),
 			gas_required: output.gas_meter.gas_required(),
 			storage_deposit: output.storage_deposit,
 			debug_message: debug_message.unwrap_or_default().to_vec(),
-			events: Some(System::events()), /* TODO: is it okay to call System::events() here?
-			                                 * The function says it should only be used in tests.
-			                                 * But what about offchain calls? */
+			events: Some(events),
 		}
 	}
 

frame/contracts/src/tests.rs

@@ -458,7 +458,7 @@ fn compile_module<T>(fixture_name: &str) -> wat::Result<(Vec<u8>, <T::Hashing as
 where
 	T: frame_system::Config,
 {
-	let fixture_path = ["fixtures/", fixture_name, ".wat"].concat();
+	let fixture_path = ["frame/contracts/fixtures/", fixture_name, ".wat"].concat();
 	let wasm_binary = wat::parse_file(fixture_path)?;
 	let code_hash = T::Hashing::hash(&wasm_binary);
 	Ok((wasm_binary, code_hash))