seal: Remove ext_dispatch_call and ext_get_runtime_storage (#6464)

Those are way too hard to audit and make only sense with specific
chains. They shouldn't be in the core API.

bin/node/runtime/src/lib.rs

@@ -582,7 +582,6 @@ impl pallet_contracts::Trait for Runtime {
 	type Time = Timestamp;
 	type Randomness = RandomnessCollectiveFlip;
 	type Currency = Balances;
-	type Call = Call;
 	type Event = Event;
 	type DetermineContractAddress = pallet_contracts::SimpleAddressDeterminer<Runtime>;
 	type TrieIdGenerator = pallet_contracts::TrieIdFromParentCounter<Runtime>;

frame/contracts/fixtures/restoration.wat

@@ -51,8 +51,8 @@
 
 	;; Code hash of SET_RENT
 	(data (i32.const 264)
-		"\c2\1c\41\10\a5\22\d8\59\1c\4c\77\35\dd\2d\bf\a1"
-		"\13\0b\50\93\76\9b\92\31\97\b7\c5\74\26\aa\38\2a"
+		"\ab\d6\58\65\1e\83\6e\4a\18\0d\f2\6d\bc\42\ba\e9"
+		"\3d\64\76\e5\30\5b\33\46\bb\4d\43\99\38\21\ee\32"
 	)
 
 	;; Rent allowance

frame/contracts/fixtures/set_rent.wat

@@ -1,5 +1,5 @@
 (module
-	(import "env" "ext_dispatch_call" (func $ext_dispatch_call (param i32 i32)))
+	(import "env" "ext_transfer" (func $ext_transfer (param i32 i32 i32 i32) (result i32)))
 	(import "env" "ext_set_storage" (func $ext_set_storage (param i32 i32 i32)))
 	(import "env" "ext_clear_storage" (func $ext_clear_storage (param i32)))
 	(import "env" "ext_set_rent_allowance" (func $ext_set_rent_allowance (param i32 i32)))
@@ -23,11 +23,13 @@
 		)
 	)
 
-	;; transfer 50 to ALICE
+	;; transfer 50 to CHARLIE
 	(func $call_2
-		(call $ext_dispatch_call
-			(i32.const 68)
-			(i32.const 11)
+		(call $assert
+			(i32.eq
+				(call $ext_transfer (i32.const 68) (i32.const 8) (i32.const 76) (i32.const 8))
+				(i32.const 0)
+			)
 		)
 	)
 
@@ -96,6 +98,9 @@
 	;; Encoding of 10 in balance
 	(data (i32.const 0) "\28")
 
-	;; Encoding of call transfer 50 to CHARLIE
-	(data (i32.const 68) "\00\00\03\00\00\00\00\00\00\00\C8")
+	;; encoding of Charlies's account id
+	(data (i32.const 68) "\03")
+
+	;; encoding of 50 balance
+	(data (i32.const 76) "\32")
 )

frame/contracts/src/exec.rs

@@ -29,7 +29,6 @@ use frame_support::{
 };
 
 pub type AccountIdOf<T> = <T as frame_system::Trait>::AccountId;
-pub type CallOf<T> = <T as Trait>::Call;
 pub type MomentOf<T> = <<T as Trait>::Time as Time>::Moment;
 pub type SeedOf<T> = <T as frame_system::Trait>::Hash;
 pub type BlockNumberOf<T> = <T as frame_system::Trait>::BlockNumber;
@@ -151,9 +150,6 @@ pub trait Ext {
 		input_data: Vec<u8>,
 	) -> ExecResult;
 
-	/// Notes a call dispatch.
-	fn note_dispatch_call(&mut self, call: CallOf<Self::T>);
-
 	/// Restores the given destination contract sacrificing the current one.
 	///
 	/// Since this function removes the self contract eagerly, if succeeded, no further actions should
@@ -274,23 +270,11 @@ impl<T: Trait> Token<T> for ExecFeeToken {
 	}
 }
 
-#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq, Clone))]
-#[derive(sp_runtime::RuntimeDebug)]
-pub enum DeferredAction<T: Trait> {
-	DispatchRuntimeCall {
-		/// The account id of the contract who dispatched this call.
-		origin: T::AccountId,
-		/// The call to dispatch.
-		call: <T as Trait>::Call,
-	},
-}
-
 pub struct ExecutionContext<'a, T: Trait + 'a, V, L> {
 	pub caller: Option<&'a ExecutionContext<'a, T, V, L>>,
 	pub self_account: T::AccountId,
 	pub self_trie_id: Option<TrieId>,
 	pub depth: usize,
-	pub deferred: Vec<DeferredAction<T>>,
 	pub config: &'a Config<T>,
 	pub vm: &'a V,
 	pub loader: &'a L,
@@ -314,7 +298,6 @@ where
 			self_trie_id: None,
 			self_account: origin,
 			depth: 0,
-			deferred: Vec::new(),
 			config: &cfg,
 			vm: &vm,
 			loader: &loader,
@@ -331,7 +314,6 @@ where
 			self_trie_id: trie_id,
 			self_account: dest,
 			depth: self.depth + 1,
-			deferred: Vec::new(),
 			config: self.config,
 			vm: self.vm,
 			loader: self.loader,
@@ -532,21 +514,14 @@ where
 		where F: FnOnce(&mut ExecutionContext<T, V, L>) -> ExecResult
 	{
 		use frame_support::storage::TransactionOutcome::*;
-		let (output, deferred) = {
-			let mut nested = self.nested(dest, trie_id);
-			let output = frame_support::storage::with_transaction(|| {
-				let output = func(&mut nested);
-				match output {
-					Ok(ref rv) if rv.is_success() => Commit(output),
-					_ => Rollback(output),
-				}
-			})?;
-			(output, nested.deferred)
-		};
-		if output.is_success() {
-			self.deferred.extend(deferred);
-		}
-		Ok(output)
+		let mut nested = self.nested(dest, trie_id);
+		frame_support::storage::with_transaction(|| {
+			let output = func(&mut nested);
+			match output {
+				Ok(ref rv) if rv.is_success() => Commit(output),
+				_ => Rollback(output),
+			}
+		})
 	}
 
 	/// Returns whether a contract, identified by address, is currently live in the execution
@@ -767,13 +742,6 @@ where
 		self.ctx.call(to.clone(), value, gas_meter, input_data)
 	}
 
-	fn note_dispatch_call(&mut self, call: CallOf<Self::T>) {
-		self.ctx.deferred.push(DeferredAction::DispatchRuntimeCall {
-			origin: self.ctx.self_account.clone(),
-			call,
-		});
-	}
-
 	fn restore_to(
 		&mut self,
 		dest: AccountIdOf<Self::T>,

frame/contracts/src/lib.rs

@@ -106,16 +106,13 @@ use sp_runtime::{
 	},
 	RuntimeDebug,
 };
-use frame_support::dispatch::{
-	PostDispatchInfo, DispatchResult, Dispatchable, DispatchResultWithPostInfo
-};
 use frame_support::{
-	Parameter, decl_module, decl_event, decl_storage, decl_error,
-	parameter_types, IsSubType, storage::child::ChildInfo,
+	decl_module, decl_event, decl_storage, decl_error,
+	parameter_types, storage::child::ChildInfo,
+	dispatch::{DispatchResult, DispatchResultWithPostInfo},
+	traits::{OnUnbalanced, Currency, Get, Time, Randomness},
 };
-use frame_support::traits::{OnUnbalanced, Currency, Get, Time, Randomness};
-use frame_support::weights::GetDispatchInfo;
-use frame_system::{self as system, ensure_signed, RawOrigin, ensure_root};
+use frame_system::{self as system, ensure_signed, ensure_root};
 use pallet_contracts_primitives::{RentProjection, ContractAccessError};
 use frame_support::weights::Weight;
 
@@ -321,12 +318,6 @@ pub trait Trait: frame_system::Trait {
 	/// The currency in which fees are paid and contract balances are held.
 	type Currency: Currency<Self::AccountId>;
 
-	/// The outer call dispatch type.
-	type Call:
-		Parameter +
-		Dispatchable<PostInfo=PostDispatchInfo, Origin=<Self as frame_system::Trait>::Origin> +
-		IsSubType<Module<Self>, Self> + GetDispatchInfo;
-
 	/// The overarching event type.
 	type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;
 
@@ -644,30 +635,7 @@ impl<T: Trait> Module<T> {
 		let vm = WasmVm::new(&cfg.schedule);
 		let loader = WasmLoader::new(&cfg.schedule);
 		let mut ctx = ExecutionContext::top_level(origin.clone(), &cfg, &vm, &loader);
-
-		let result = func(&mut ctx, gas_meter);
-
-		// Execute deferred actions.
-		ctx.deferred.into_iter().for_each(|deferred| {
-			use self::exec::DeferredAction::*;
-			match deferred {
-				DispatchRuntimeCall {
-					origin: who,
-					call,
-				} => {
-					let info = call.get_dispatch_info();
-					let result = call.dispatch(RawOrigin::Signed(who.clone()).into());
-					let post_info = match result {
-						Ok(post_info) => post_info,
-						Err(err) => err.post_info,
-					};
-					gas_meter.refund(post_info.calc_unspent(&info));
-					Self::deposit_event(RawEvent::Dispatched(who, result.is_ok()));
-				}
-			}
-		});
-
-		result
+		func(&mut ctx, gas_meter)
 	}
 }