Time-delay proxies (#6770)

* Time-delay proxies. * Tests * Initial couple of benchmarks * Fix up runtime * Last couple of benchmarks * Tests * Docs * Migration * add tests to proxy benchmarks * generated benchmarks, not integrated * Fix weight trait * integrate weightinfo * default weight * Grumble * Deduplication, split proxy from announced_proxy and don't require reauthentication * Fix * Remoe superfluous * Typos * Indent * Fix * Fixes * rename 'proxy_announced' -> 'announced_proxy' * flip rename * comments and spacing * fix proxy_announced * remove unneeded `execute` marker * Avoid unneeded changes to extrinsic indices * Cleanup * Fixes * Update Benchmarks and Weights for Delayed Proxy (#6811) * update bechmarks to parameterize announcements * remove announcement param from proxy * Update pallet_proxy.rs * Update weights * Bump runtime * Fix benchmark Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
2026-04-28 05:07:55 +00:00 · 2020-08-23 15:52:40 +05:00
parent e7f25ebda8
commit cf4c744eb3
8 changed files with 866 additions and 127 deletions
@@ -19,6 +19,10 @@
 //! A module allowing accounts to give permission to other accounts to dispatch types of calls from
 //! their signed origin.
 //!
+//! The accounts to which permission is delegated may be requied to announce the action that they
+//! wish to execute some duration prior to execution happens. In this case, the target account may
+//! reject the announcement and in doing so, veto the execution.
+//!
 //! - [`proxy::Trait`](./trait.Trait.html)
 //! - [`Call`](./enum.Call.html)
 //!
@@ -37,23 +41,27 @@
 use sp_std::prelude::*;
 use codec::{Encode, Decode};
 use sp_io::hashing::blake2_256;
-use sp_runtime::{DispatchResult, traits::{Dispatchable, Zero}};
-use sp_runtime::traits::Member;
+use sp_runtime::{DispatchResult, traits::{Dispatchable, Zero, Hash, Member, Saturating}};
 use frame_support::{
-	decl_module, decl_event, decl_error, decl_storage, Parameter, ensure, traits::{
-		Get, ReservableCurrency, Currency, InstanceFilter,
-		OriginTrait, IsType,
-	}, weights::{Weight, GetDispatchInfo, constants::{WEIGHT_PER_MICROS, WEIGHT_PER_NANOS}},
-	dispatch::{PostDispatchInfo, IsSubType},
+	decl_module, decl_event, decl_error, decl_storage, Parameter, ensure, RuntimeDebug, traits::{
+		Get, ReservableCurrency, Currency, InstanceFilter, OriginTrait, IsType,
+	}, weights::{Weight, GetDispatchInfo},
+	dispatch::{PostDispatchInfo, IsSubType}, storage::IterableStorageMap,
 };
 use frame_system::{self as system, ensure_signed};
+use frame_support::dispatch::DispatchError;

 mod tests;
 mod benchmarking;
+mod default_weight;

 type BalanceOf<T> = <<T as Trait>::Currency as Currency<<T as frame_system::Trait>::AccountId>>::Balance;

 pub trait WeightInfo {
+	fn proxy_announced(a: u32, p: u32, ) -> Weight;
+	fn remove_announcement(a: u32, p: u32, ) -> Weight;
+	fn reject_announcement(a: u32, p: u32, ) -> Weight;
+	fn announce(a: u32, p: u32, ) -> Weight;
 	fn proxy(p: u32, ) -> Weight;
 	fn add_proxy(p: u32, ) -> Weight;
 	fn remove_proxy(p: u32, ) -> Weight;
@@ -62,15 +70,6 @@ pub trait WeightInfo {
 	fn kill_anonymous(p: u32, ) -> Weight;
 }

-impl WeightInfo for () {
-	fn proxy(_p: u32, ) -> Weight { 1_000_000_000 }
-	fn add_proxy(_p: u32, ) -> Weight { 1_000_000_000 }
-	fn remove_proxy(_p: u32, ) -> Weight { 1_000_000_000 }
-	fn remove_proxies(_p: u32, ) -> Weight { 1_000_000_000 }
-	fn anonymous(_p: u32, ) -> Weight { 1_000_000_000 }
-	fn kill_anonymous(_p: u32, ) -> Weight { 1_000_000_000 }
-}
-
 /// Configuration trait.
 pub trait Trait: frame_system::Trait {
 	/// The overarching event type.
@@ -108,19 +107,67 @@ pub trait Trait: frame_system::Trait {

 	/// Weight information for extrinsics in this pallet.
 	type WeightInfo: WeightInfo;
+
+	/// The maximum amount of time-delayed announcements that are allowed to be pending.
+	type MaxPending: Get<u32>;
+
+	/// The type of hash used for hashing the call.
+	type CallHasher: Hash;
+
+	/// The base amount of currency needed to reserve for creating an announcement.
+	///
+	/// This is held when a new storage item holding a `Balance` is created (typically 16 bytes).
+	type AnnouncementDepositBase: Get<BalanceOf<Self>>;
+
+	/// The amount of currency needed per announcement made.
+	///
+	/// This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)
+	/// into a pre-existing storage value.
+	type AnnouncementDepositFactor: Get<BalanceOf<Self>>;
 }

+/// The parameters under which a particular account has a proxy relationship with some other
+/// account.
+#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, RuntimeDebug)]
+pub struct ProxyDefinition<AccountId, ProxyType, BlockNumber> {
+	/// The account which may act on behalf of another.
+	delegate: AccountId,
+	/// A value defining the subset of calls that it is allowed to make.
+	proxy_type: ProxyType,
+	/// The number of blocks that an announcement must be in place for before the corresponding call
+	/// may be dispatched. If zero, then no announcement is needed.
+	delay: BlockNumber,
+}
+
+/// Details surrounding a specific instance of an announcement to make a call.
+#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug)]
+pub struct Announcement<AccountId, Hash, BlockNumber> {
+	/// The account which made the announcement.
+	real: AccountId,
+	/// The hash of the call to be made.
+	call_hash: Hash,
+	/// The height at which the announcement was made.
+	height: BlockNumber,
+}
+
+type CallHashOf<T> = <<T as Trait>::CallHasher as Hash>::Output;
+
 decl_storage! {
 	trait Store for Module<T: Trait> as Proxy {
 		/// The set of account proxies. Maps the account which has delegated to the accounts
 		/// which are being delegated to, together with the amount held on deposit.
-		pub Proxies: map hasher(twox_64_concat) T::AccountId => (Vec<(T::AccountId, T::ProxyType)>, BalanceOf<T>);
+		pub Proxies: map hasher(twox_64_concat) T::AccountId
+			=> (Vec<ProxyDefinition<T::AccountId, T::ProxyType, T::BlockNumber>>, BalanceOf<T>);
+
+		/// The announcements made by the proxy (key).
+		pub Announcements: map hasher(twox_64_concat) T::AccountId
+			=> (Vec<Announcement<T::AccountId, CallHashOf<T>, T::BlockNumber>>, BalanceOf<T>);
 	}
 }

 decl_error! {
 	pub enum Error for Module<T: Trait> {
-		/// There are too many proxies registered.
+		/// There are too many proxies registered or too many announcements pending.
 		TooMany,
 		/// Proxy registration not found.
 		NotFound,
@@ -132,6 +179,8 @@ decl_error! {
 		Duplicate,
 		/// Call may not be made by proxy because it may escalate its privileges.
 		NoPermission,
+		/// Announcement, if made at all, was made too recently.
+		Unannounced,
 	}
 }

@@ -139,13 +188,16 @@ decl_event! {
 	/// Events type.
 	pub enum Event<T> where
 		AccountId = <T as frame_system::Trait>::AccountId,
-		ProxyType = <T as Trait>::ProxyType
+		ProxyType = <T as Trait>::ProxyType,
+		Hash = CallHashOf<T>,
 	{
 		/// A proxy was executed correctly, with the given [result].
 		ProxyExecuted(DispatchResult),
 		/// Anonymous account has been created by new proxy with given
 		/// disambiguation index and proxy type. [anonymous, who, proxy_type, disambiguation_index]
 		AnonymousCreated(AccountId, AccountId, ProxyType, u16),
+		/// An announcement was placed to make a call in the future. [real, proxy, call_hash]
+		Announced(AccountId, AccountId, Hash),
 	}
 }

@@ -165,9 +217,36 @@ decl_module! {
 		/// The maximum amount of proxies allowed for a single account.
 		const MaxProxies: u16 = T::MaxProxies::get();

+		/// `MaxPending` metadata shadow.
+		const MaxPending: u32 = T::MaxPending::get();
+
+		/// `AnnouncementDepositBase` metadata shadow.
+		const AnnouncementDepositBase: BalanceOf<T> = T::AnnouncementDepositBase::get();
+
+		/// `AnnouncementDepositFactor` metadata shadow.
+		const AnnouncementDepositFactor: BalanceOf<T> = T::AnnouncementDepositFactor::get();
+
+		fn on_runtime_upgrade() -> Weight {
+			Proxies::<T>::translate::<(Vec<(T::AccountId, T::ProxyType)>, BalanceOf<T>), _>(
+				|_, (targets, deposit)| Some((
+					targets.into_iter()
+						.map(|(a, t)| ProxyDefinition {
+							delegate: a,
+							proxy_type: t,
+							delay: Zero::zero(),
+						})
+						.collect::<Vec<_>>(),
+					deposit,
+				))
+			);
+			T::MaximumBlockWeight::get()
+		}
+
 		/// Dispatch the given `call` from an account that the sender is authorised for through
 		/// `add_proxy`.
 		///
+		/// Removes any corresponding announcement(s).
+		///
 		/// The dispatch origin for this call must be _Signed_.
 		///
 		/// Parameters:
@@ -176,43 +255,24 @@ decl_module! {
 		/// - `call`: The call to be made by the `real` account.
 		///
 		/// # <weight>
-		/// P is the number of proxies the user has
-		/// - Base weight: 19.87 + .141 * P µs
-		/// - DB weight: 1 storage read.
-		/// - Plus the weight of the `call`
+		/// Weight is a function of the number of proxies the user has (P).
 		/// # </weight>
 		#[weight = {
 			let di = call.get_dispatch_info();
-			(T::DbWeight::get().reads(1)
-				.saturating_add(di.weight)
-				.saturating_add(20 * WEIGHT_PER_MICROS)
-				.saturating_add((140 * WEIGHT_PER_NANOS).saturating_mul(T::MaxProxies::get().into())),
+			(T::WeightInfo::proxy(T::MaxProxies::get().into())
+				.saturating_add(di.weight),
 			di.class)
 		}]
 		fn proxy(origin,
 			real: T::AccountId,
 			force_proxy_type: Option<T::ProxyType>,
-			call: Box<<T as Trait>::Call>
+			call: Box<<T as Trait>::Call>,
 		) {
 			let who = ensure_signed(origin)?;
-			let (_, proxy_type) = Proxies::<T>::get(&real).0.into_iter()
-				.find(|x| &x.0 == &who && force_proxy_type.as_ref().map_or(true, |y| &x.1 == y))
-				.ok_or(Error::<T>::NotProxy)?;
+			let def = Self::find_proxy(&real, &who, force_proxy_type)?;
+			ensure!(def.delay.is_zero(), Error::<T>::Unannounced);

-			// This is a freshly authenticated new account, the origin restrictions doesn't apply.
-			let mut origin: T::Origin = frame_system::RawOrigin::Signed(real).into();
-			origin.add_filter(move |c: &<T as frame_system::Trait>::Call| {
-				let c = <T as Trait>::Call::from_ref(c);
-				match c.is_sub_type() {
-					Some(Call::add_proxy(_, ref pt)) | Some(Call::remove_proxy(_, ref pt))
-						if !proxy_type.is_superset(&pt) => false,
-					Some(Call::remove_proxies(..)) | Some(Call::kill_anonymous(..))
-					    if proxy_type != T::ProxyType::default() => false,
-					_ => proxy_type.filter(c)
-				}
-			});
-			let e = call.dispatch(origin);
-			Self::deposit_event(RawEvent::ProxyExecuted(e.map(|_| ()).map_err(|e| e.error)));
+			Self::do_proxy(def, real, *call);
 		}

 		/// Register a proxy account for the sender that is able to make calls on its behalf.
@@ -224,21 +284,20 @@ decl_module! {
 		/// - `proxy_type`: The permissions allowed for this proxy account.
 		///
 		/// # <weight>
-		/// P is the number of proxies the user has
-		/// - Base weight: 17.48 + .176 * P µs
-		/// - DB weight: 1 storage read and write.
+		/// Weight is a function of the number of proxies the user has (P).
 		/// # </weight>
-		#[weight = T::DbWeight::get().reads_writes(1, 1)
-			.saturating_add(18 * WEIGHT_PER_MICROS)
-			.saturating_add((200 * WEIGHT_PER_NANOS).saturating_mul(T::MaxProxies::get().into()))
-		]
-		fn add_proxy(origin, proxy: T::AccountId, proxy_type: T::ProxyType) -> DispatchResult {
+		#[weight = T::WeightInfo::add_proxy(T::MaxProxies::get().into())]
+		fn add_proxy(origin,
+			delegate: T::AccountId,
+			proxy_type: T::ProxyType,
+			delay: T::BlockNumber,
+		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Proxies::<T>::try_mutate(&who, |(ref mut proxies, ref mut deposit)| {
 				ensure!(proxies.len() < T::MaxProxies::get() as usize, Error::<T>::TooMany);
-				let typed_proxy = (proxy, proxy_type);
-				let i = proxies.binary_search(&typed_proxy).err().ok_or(Error::<T>::Duplicate)?;
-				proxies.insert(i, typed_proxy);
+				let proxy_def = ProxyDefinition { delegate, proxy_type, delay };
+				let i = proxies.binary_search(&proxy_def).err().ok_or(Error::<T>::Duplicate)?;
+				proxies.insert(i, proxy_def);
 				let new_deposit = T::ProxyDepositBase::get()
 					+ T::ProxyDepositFactor::get() * (proxies.len() as u32).into();
 				if new_deposit > *deposit {
@@ -260,20 +319,19 @@ decl_module! {
 		/// - `proxy_type`: The permissions currently enabled for the removed proxy account.
 		///
 		/// # <weight>
-		/// P is the number of proxies the user has
-		/// - Base weight: 14.37 + .164 * P µs
-		/// - DB weight: 1 storage read and write.
+		/// Weight is a function of the number of proxies the user has (P).
 		/// # </weight>
-		#[weight = T::DbWeight::get().reads_writes(1, 1)
-			.saturating_add(14 * WEIGHT_PER_MICROS)
-			.saturating_add((160 * WEIGHT_PER_NANOS).saturating_mul(T::MaxProxies::get().into()))
-		]
-		fn remove_proxy(origin, proxy: T::AccountId, proxy_type: T::ProxyType) -> DispatchResult {
+		#[weight = T::WeightInfo::remove_proxy(T::MaxProxies::get().into())]
+		fn remove_proxy(origin,
+			delegate: T::AccountId,
+			proxy_type: T::ProxyType,
+			delay: T::BlockNumber,
+		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			Proxies::<T>::try_mutate_exists(&who, |x| {
 				let (mut proxies, old_deposit) = x.take().ok_or(Error::<T>::NotFound)?;
-				let typed_proxy = (proxy, proxy_type);
-				let i = proxies.binary_search(&typed_proxy).ok().ok_or(Error::<T>::NotFound)?;
+				let proxy_def = ProxyDefinition { delegate, proxy_type, delay };
+				let i = proxies.binary_search(&proxy_def).ok().ok_or(Error::<T>::NotFound)?;
 				proxies.remove(i);
 				let new_deposit = if proxies.is_empty() {
 					BalanceOf::<T>::zero()
@@ -300,14 +358,9 @@ decl_module! {
 		/// the unreserved fees will be inaccessible. **All access to this account will be lost.**
 		///
 		/// # <weight>
-		/// P is the number of proxies the user has
-		/// - Base weight: 13.73 + .129 * P µs
-		/// - DB weight: 1 storage read and write.
+		/// Weight is a function of the number of proxies the user has (P).
 		/// # </weight>
-		#[weight = T::DbWeight::get().reads_writes(1, 1)
-			.saturating_add(14 * WEIGHT_PER_MICROS)
-			.saturating_add((130 * WEIGHT_PER_NANOS).saturating_mul(T::MaxProxies::get().into()))
-		]
+		#[weight = T::WeightInfo::remove_proxies(T::MaxProxies::get().into())]
 		fn remove_proxies(origin) {
 			let who = ensure_signed(origin)?;
 			let (_, old_deposit) = Proxies::<T>::take(&who);
@@ -325,6 +378,8 @@ decl_module! {
 		/// - `index`: A disambiguation index, in case this is called multiple times in the same
 		/// transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
 		/// want to use `0`.
+		/// - `delay`: The announcement period required of the initial proxy. Will generally be
+		/// zero.
 		///
 		/// Fails with `Duplicate` if this has already been called in this transaction, from the
 		/// same sender, with the same parameters.
@@ -332,22 +387,23 @@ decl_module! {
 		/// Fails if there are insufficient funds to pay for deposit.
 		///
 		/// # <weight>
-		/// P is the number of proxies the user has
-		/// - Base weight: 36.48 + .039 * P µs
-		/// - DB weight: 1 storage read and write.
+		/// Weight is a function of the number of proxies the user has (P).
 		/// # </weight>
-		#[weight = T::DbWeight::get().reads_writes(1, 1)
-			.saturating_add(36 * WEIGHT_PER_MICROS)
-			.saturating_add((40 * WEIGHT_PER_NANOS).saturating_mul(T::MaxProxies::get().into()))
-		]
-		fn anonymous(origin, proxy_type: T::ProxyType, index: u16) {
+		/// TODO: Might be over counting 1 read
+		#[weight = T::WeightInfo::anonymous(T::MaxProxies::get().into())]
+		fn anonymous(origin, proxy_type: T::ProxyType, delay: T::BlockNumber, index: u16) {
 			let who = ensure_signed(origin)?;

 			let anonymous = Self::anonymous_account(&who, &proxy_type, index, None);
 			ensure!(!Proxies::<T>::contains_key(&anonymous), Error::<T>::Duplicate);
 			let deposit = T::ProxyDepositBase::get() + T::ProxyDepositFactor::get();
 			T::Currency::reserve(&who, deposit)?;
-			Proxies::<T>::insert(&anonymous, (vec![(who.clone(), proxy_type.clone())], deposit));
+			let proxy_def = ProxyDefinition {
+				delegate: who.clone(),
+				proxy_type: proxy_type.clone(),
+				delay,
+			};
+			Proxies::<T>::insert(&anonymous, (vec![proxy_def], deposit));
 			Self::deposit_event(RawEvent::AnonymousCreated(anonymous, who, proxy_type, index));
 		}

@@ -369,14 +425,9 @@ decl_module! {
 		/// account whose `anonymous` call has corresponding parameters.
 		///
 		/// # <weight>
-		/// P is the number of proxies the user has
-		/// - Base weight: 15.65 + .137 * P µs
-		/// - DB weight: 1 storage read and write.
+		/// Weight is a function of the number of proxies the user has (P).
 		/// # </weight>
-		#[weight = T::DbWeight::get().reads_writes(1, 1)
-			.saturating_add(15 * WEIGHT_PER_MICROS)
-			.saturating_add((140 * WEIGHT_PER_NANOS).saturating_mul(T::MaxProxies::get().into()))
-		]
+		#[weight = T::WeightInfo::kill_anonymous(T::MaxProxies::get().into())]
 		fn kill_anonymous(origin,
 			spawner: T::AccountId,
 			proxy_type: T::ProxyType,
@@ -393,6 +444,140 @@ decl_module! {
 			let (_, deposit) = Proxies::<T>::take(&who);
 			T::Currency::unreserve(&spawner, deposit);
 		}
+
+		/// Publish the hash of a proxy-call that will be made in the future.
+		///
+		/// This must be called some number of blocks before the corresponding `proxy` is attempted
+		/// if the delay associated with the proxy relationship is greater than zero.
+		///
+		/// No more than `MaxPending` announcements may be made at any one time.
+		///
+		/// This will take a deposit of `AnnouncementDepositFactor` as well as
+		/// `AnnouncementDepositBase` if there are no other pending announcements.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a proxy of `real`.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `call_hash`: The hash of the call to be made by the `real` account.
+		///
+		/// # <weight>
+		/// Weight is a function of:
+		/// - A: the number of announcements made.
+		/// - P: the number of proxies the user has.
+		/// # </weight>
+		#[weight = T::WeightInfo::announce(T::MaxPending::get(), T::MaxProxies::get().into())]
+		fn announce(origin, real: T::AccountId, call_hash: CallHashOf<T>) {
+			let who = ensure_signed(origin)?;
+			Proxies::<T>::get(&real).0.into_iter()
+				.find(|x| &x.delegate == &who)
+				.ok_or(Error::<T>::NotProxy)?;
+
+			let announcement = Announcement {
+				real: real.clone(),
+				call_hash: call_hash.clone(),
+				height: system::Module::<T>::block_number(),
+			};
+
+			Announcements::<T>::try_mutate(&who, |(ref mut pending, ref mut deposit)| {
+				ensure!(pending.len() < T::MaxPending::get() as usize, Error::<T>::TooMany);
+				pending.push(announcement);
+				Self::rejig_deposit(
+					&who,
+					*deposit,
+					T::AnnouncementDepositBase::get(),
+					T::AnnouncementDepositFactor::get(),
+					pending.len(),
+				).map(|d| d.expect("Just pushed; pending.len() > 0; rejig_deposit returns Some; qed"))
+				.map(|d| *deposit = d)
+			})?;
+			Self::deposit_event(RawEvent::Announced(real, who, call_hash));
+		}
+
+		/// Remove a given announcement.
+		///
+		/// May be called by a proxy account to remove a call they previously announced and return
+		/// the deposit.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `call_hash`: The hash of the call to be made by the `real` account.
+		///
+		/// # <weight>
+		/// Weight is a function of:
+		/// - A: the number of announcements made.
+		/// - P: the number of proxies the user has.
+		/// # </weight>
+		#[weight = T::WeightInfo::remove_announcement(T::MaxPending::get(), T::MaxProxies::get().into())]
+		fn remove_announcement(origin, real: T::AccountId, call_hash: CallHashOf<T>) {
+			let who = ensure_signed(origin)?;
+			Self::edit_announcements(&who, |ann| ann.real != real || ann.call_hash != call_hash)?;
+		}
+
+		/// Remove the given announcement of a delegate.
+		///
+		/// May be called by a target (proxied) account to remove a call that one of their delegates
+		/// (`delegate`) has announced they want to execute. The deposit is returned.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `delegate`: The account that previously announced the call.
+		/// - `call_hash`: The hash of the call to be made.
+		///
+		/// # <weight>
+		/// Weight is a function of:
+		/// - A: the number of announcements made.
+		/// - P: the number of proxies the user has.
+		/// # </weight>
+		#[weight = T::WeightInfo::reject_announcement(T::MaxPending::get(), T::MaxProxies::get().into())]
+		fn reject_announcement(origin, delegate: T::AccountId, call_hash: CallHashOf<T>) {
+			let who = ensure_signed(origin)?;
+			Self::edit_announcements(&delegate, |ann| ann.real != who || ann.call_hash != call_hash)?;
+		}
+
+		/// Dispatch the given `call` from an account that the sender is authorised for through
+		/// `add_proxy`.
+		///
+		/// Removes any corresponding announcement(s).
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+		/// - `call`: The call to be made by the `real` account.
+		///
+		/// # <weight>
+		/// Weight is a function of:
+		/// - A: the number of announcements made.
+		/// - P: the number of proxies the user has.
+		/// # </weight>
+		#[weight = {
+			let di = call.get_dispatch_info();
+			(T::WeightInfo::proxy_announced(T::MaxPending::get(), T::MaxProxies::get().into())
+				.saturating_add(di.weight),
+			di.class)
+		}]
+		fn proxy_announced(origin,
+			delegate: T::AccountId,
+			real: T::AccountId,
+			force_proxy_type: Option<T::ProxyType>,
+			call: Box<<T as Trait>::Call>,
+		) {
+			ensure_signed(origin)?;
+			let def = Self::find_proxy(&real, &delegate, force_proxy_type)?;
+
+			let call_hash = T::CallHasher::hash_of(&call);
+			let now = system::Module::<T>::block_number();
+			Self::edit_announcements(&delegate, |ann|
+				ann.real != real || ann.call_hash != call_hash || now.saturating_sub(ann.height) < def.delay
+			).map_err(|_| Error::<T>::Unannounced)?;
+
+			Self::do_proxy(def, real, *call);
+		}
 	}
 }

@@ -411,4 +596,82 @@ impl<T: Trait> Module<T> {
 			.using_encoded(blake2_256);
 		T::AccountId::decode(&mut &entropy[..]).unwrap_or_default()
 	}
+
+	fn rejig_deposit(
+		who: &T::AccountId,
+		old_deposit: BalanceOf<T>,
+		base: BalanceOf<T>,
+		factor: BalanceOf<T>,
+		len: usize,
+	) -> Result<Option<BalanceOf<T>>, DispatchError> {
+		let new_deposit = if len == 0 {
+			BalanceOf::<T>::zero()
+		} else {
+			base + factor * (len as u32).into()
+		};
+		if new_deposit > old_deposit {
+			T::Currency::reserve(&who, new_deposit - old_deposit)?;
+		} else if new_deposit < old_deposit {
+			T::Currency::unreserve(&who, old_deposit - new_deposit);
+		}
+		Ok(if len == 0 {
+			None
+		} else {
+			Some(new_deposit)
+		})
+	}
+
+	fn edit_announcements<
+		F: FnMut(&Announcement<T::AccountId, CallHashOf<T>, T::BlockNumber>) -> bool
+	>(delegate: &T::AccountId, f: F) -> DispatchResult {
+		Announcements::<T>::try_mutate_exists(delegate, |x| {
+			let (mut pending, old_deposit) = x.take().ok_or(Error::<T>::NotFound)?;
+			let orig_pending_len = pending.len();
+			pending.retain(f);
+			ensure!(orig_pending_len > pending.len(), Error::<T>::NotFound);
+			*x = Self::rejig_deposit(
+				delegate,
+				old_deposit,
+				T::AnnouncementDepositBase::get(),
+				T::AnnouncementDepositFactor::get(),
+				pending.len(),
+			)?.map(|deposit| (pending, deposit));
+			Ok(())
+		})
+	}
+
+	fn find_proxy(
+		real: &T::AccountId,
+		delegate: &T::AccountId,
+		force_proxy_type: Option<T::ProxyType>,
+	) -> Result<ProxyDefinition<T::AccountId, T::ProxyType, T::BlockNumber>, DispatchError> {
+		let f = |x: &ProxyDefinition<T::AccountId, T::ProxyType, T::BlockNumber>| -> bool {
+			&x.delegate == delegate && force_proxy_type.as_ref().map_or(true, |y| &x.proxy_type == y)
+		};
+		Ok(Proxies::<T>::get(real).0.into_iter().find(f).ok_or(Error::<T>::NotProxy)?)
+	}
+
+	fn do_proxy(
+		def: ProxyDefinition<T::AccountId, T::ProxyType, T::BlockNumber>,
+		real: T::AccountId,
+		call: <T as Trait>::Call,
+	) {
+		// This is a freshly authenticated new account, the origin restrictions doesn't apply.
+		let mut origin: T::Origin = frame_system::RawOrigin::Signed(real).into();
+		origin.add_filter(move |c: &<T as frame_system::Trait>::Call| {
+			let c = <T as Trait>::Call::from_ref(c);
+			// We make sure the proxy call does access this pallet to change modify proxies.
+			match c.is_sub_type() {
+				// Proxy call cannot add or remove a proxy with more permissions than it already has.
+				Some(Call::add_proxy(_, ref pt, _)) | Some(Call::remove_proxy(_, ref pt, _))
+					if !def.proxy_type.is_superset(&pt) => false,
+				// Proxy call cannot remove all proxies or kill anonymous proxies unless it has full permissions.
+				Some(Call::remove_proxies(..)) | Some(Call::kill_anonymous(..))
+					if def.proxy_type != T::ProxyType::default() => false,
+				_ => def.proxy_type.filter(c)
+			}
+		});
+		let e = call.dispatch(origin);
+		Self::deposit_event(RawEvent::ProxyExecuted(e.map(|_| ()).map_err(|e| e.error)));
+	}
 }