Time-delay proxies

bin/node/runtime/src/lib.rs

@@ -215,6 +215,9 @@ parameter_types! {
  // Additional storage item size of 33 bytes.
  pub const ProxyDepositFactor: Balance = deposit(0, 33);
  pub const MaxProxies: u16 = 32;
+ pub const AnnouncementDepositBase: Balance = deposit(1, 8);
+ pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
+ pub const MaxPending: u16 = 32;
 }
 
 /// The type used to represent the kinds of proxying allowed.
@@ -260,7 +263,11 @@ impl pallet_proxy::Trait for Runtime {
  type ProxyDepositBase = ProxyDepositBase;
  type ProxyDepositFactor = ProxyDepositFactor;
  type MaxProxies = MaxProxies;
- type WeightInfo = ();
+ type WeightInfo = weights::pallet_proxy::WeightInfo;
+ type MaxPending = MaxPending;
+ type CallHasher = BlakeTwo256;
+ type AnnouncementDepositBase = AnnouncementDepositBase;
+ type AnnouncementDepositFactor = AnnouncementDepositFactor;
 }
 
 parameter_types! {

bin/node/runtime/src/weights/mod.rs

@@ -16,3 +16,4 @@
 //! A list of the different weight modules for our runtime.
 
 pub mod pallet_balances;
+pub mod pallet_proxy;

bin/node/runtime/src/weights/pallet_balances.rs

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! Weights for the Balances Pallet
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 2.0.0-rc5
 
 use frame_support::weights::{Weight, constants::RocksDbWeight as DbWeight};
 

bin/node/runtime/src/weights/pallet_proxy.rs

@@ -0,0 +1,81 @@
+// Copyright (C) 2020 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 2.0.0-rc5
+
+use frame_support::weights::{Weight, constants::RocksDbWeight as DbWeight};
+
+pub struct WeightInfo;
+impl pallet_proxy::WeightInfo for WeightInfo {
+ fn proxy(p: u32, ) -> Weight {
+ (27894000 as Weight)
+ .saturating_add((196000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ }
+ fn proxy_announced(p: u32, ) -> Weight {
+ (78353000 as Weight)
+ .saturating_add((201000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(3 as Weight))
+ .saturating_add(DbWeight::get().writes(2 as Weight))
+ }
+ fn remove_announcement(p: u32, ) -> Weight {
+ (60264000 as Weight)
+ .saturating_add((4000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(2 as Weight))
+ .saturating_add(DbWeight::get().writes(2 as Weight))
+ }
+ fn reject_announcement(p: u32, ) -> Weight {
+ (60141000 as Weight)
+ .saturating_add((10000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(2 as Weight))
+ .saturating_add(DbWeight::get().writes(2 as Weight))
+ }
+ fn announce(p: u32, ) -> Weight {
+ (74751000 as Weight)
+ .saturating_add((208000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(3 as Weight))
+ .saturating_add(DbWeight::get().writes(2 as Weight))
+ }
+ fn add_proxy(p: u32, ) -> Weight {
+ (36250000 as Weight)
+ .saturating_add((223000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
+ fn remove_proxy(p: u32, ) -> Weight {
+ (32843000 as Weight)
+ .saturating_add((258000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
+ fn remove_proxies(p: u32, ) -> Weight {
+ (31834000 as Weight)
+ .saturating_add((203000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
+ fn anonymous(p: u32, ) -> Weight {
+ (50947000 as Weight)
+ .saturating_add((44000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(2 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
+ fn kill_anonymous(p: u32, ) -> Weight {
+ (34213000 as Weight)
+ .saturating_add((208000 as Weight).saturating_mul(p as Weight))
+ .saturating_add(DbWeight::get().reads(1 as Weight))
+ .saturating_add(DbWeight::get().writes(1 as Weight))
+ }
+}

frame/proxy/src/benchmarking.rs

@@ -20,21 +20,60 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-use frame_system::RawOrigin;
+use frame_system::{RawOrigin, EventRecord};
 use frame_benchmarking::{benchmarks, account};
 use sp_runtime::traits::Bounded;
 use crate::Module as Proxy;
 
 const SEED: u32 = 0;
 
+fn assert_last_event<T: Trait>(generic_event: <T as Trait>::Event) {
+ let events = frame_system::Module::<T>::events();
+ let system_event: <T as frame_system::Trait>::Event = generic_event.into();
+ // compare to the last event record
+ let EventRecord { event, .. } = &events[events.len() - 1];
+ assert_eq!(event, &system_event);
+}
+
 fn add_proxies<T: Trait>(n: u32, maybe_who: Option<T::AccountId>) -> Result<(), &'static str> {
  let caller = maybe_who.unwrap_or_else(|| account("caller", 0, SEED));
  T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
  for i in 0..n {
  Proxy::<T>::add_proxy(
  RawOrigin::Signed(caller.clone()).into(),
  account("target", i, SEED),
- T::ProxyType::default()
+ T::ProxyType::default(),
+ T::BlockNumber::zero(),
+ )?;
+ }
+ Ok(())
+}
+
+fn add_announcements<T: Trait>(
+ n: u32,
+ maybe_who: Option<T::AccountId>,
+ maybe_real: Option<T::AccountId>
+) -> Result<(), &'static str> {
+ let caller = maybe_who.unwrap_or_else(|| account("caller", 0, SEED));
+ T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+ let real = if let Some(real) = maybe_real {
+ real
+ } else {
+ let real = account("real", 0, SEED);
+ T::Currency::make_free_balance_be(&real, BalanceOf::<T>::max_value());
+ Proxy::<T>::add_proxy(
+ RawOrigin::Signed(real.clone()).into(),
+ caller.clone(),
+ T::ProxyType::default(),
+ T::BlockNumber::zero(),
+ )?;
+ real
+ };
+ for _ in 0..n {
+ Proxy::<T>::announce(
+ RawOrigin::Signed(caller.clone()).into(),
+ real.clone(),
+ T::CallHasher::hash_of(&("add_announcement", n)),
  )?;
  }
  Ok(())
@@ -49,43 +88,167 @@ benchmarks! {
  let p in ...;
  // In this case the caller is the "target" proxy
  let caller: T::AccountId = account("target", p - 1, SEED);
+ T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+ // ... and "real" is the traditional caller. This is not a typo.
+ let real: T::AccountId = account("caller", 0, SEED);
+ let call: <T as Trait>::Call = frame_system::Call::<T>::remark(vec![]).into();
+ add_announcements::<T>(T::MaxPending::get(), Some(caller.clone()), None)?;
+ }: _(RawOrigin::Signed(caller), real, Some(T::ProxyType::default()), Box::new(call), false)
+ verify {
+ assert_last_event::<T>(RawEvent::ProxyExecuted(Ok(())).into())
+ }
+
+ proxy_announced {
+ let p in ...;
+ // In this case the caller is the "target" proxy
+ let caller: T::AccountId = account("target", p - 1, SEED);
+ T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+ // ... and "real" is the traditional caller. This is not a typo.
+ let real: T::AccountId = account("caller", 0, SEED);
+ let call: <T as Trait>::Call = frame_system::Call::<T>::remark(vec![]).into();
+ Proxy::<T>::announce(
+ RawOrigin::Signed(caller.clone()).into(),
+ real.clone(),
+ T::CallHasher::hash_of(&call),
+ )?;
+ add_announcements::<T>(T::MaxPending::get() - 1, Some(caller.clone()), None)?;
+ }: proxy(RawOrigin::Signed(caller), real, Some(T::ProxyType::default()), Box::new(call), true)
+ verify {
+ assert_last_event::<T>(RawEvent::ProxyExecuted(Ok(())).into())
+ }
+
+ remove_announcement {
+ let p in ...;
+ // In this case the caller is the "target" proxy
+ let caller: T::AccountId = account("target", p - 1, SEED);
+ T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+ // ... and "real" is the traditional caller. This is not a typo.
+ let real: T::AccountId = account("caller", 0, SEED);
+ let call: <T as Trait>::Call = frame_system::Call::<T>::remark(vec![]).into();
+ Proxy::<T>::announce(
+ RawOrigin::Signed(caller.clone()).into(),
+ real.clone(),
+ T::CallHasher::hash_of(&call),
+ )?;
+ add_announcements::<T>(T::MaxPending::get() - 1, Some(caller.clone()), None)?;
+ }: _(RawOrigin::Signed(caller.clone()), real, T::CallHasher::hash_of(&call))
+ verify {
+ let (_, announcements) = Announcements::<T>::get(&caller);
+ assert_eq!(announcements.len() as u32, T::MaxPending::get() - 1);
+ }
+
+ reject_announcement {
+ let p in ...;
+ // In this case the caller is the "target" proxy
+ let caller: T::AccountId = account("target", p - 1, SEED);
+ T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+ // ... and "real" is the traditional caller. This is not a typo.
+ let real: T::AccountId = account("caller", 0, SEED);
+ let call: <T as Trait>::Call = frame_system::Call::<T>::remark(vec![]).into();
+ Proxy::<T>::announce(
+ RawOrigin::Signed(caller.clone()).into(),
+ real.clone(),
+ T::CallHasher::hash_of(&call),
+ )?;
+ add_announcements::<T>(T::MaxPending::get() - 1, Some(caller.clone()), None)?;
+ }: _(RawOrigin::Signed(real), caller.clone(), T::CallHasher::hash_of(&call))
+ verify {
+ let (_, announcements) = Announcements::<T>::get(&caller);
+ assert_eq!(announcements.len() as u32, T::MaxPending::get() - 1);
+ }
+
+ announce {
+ let p in ...;
+ // In this case the caller is the "target" proxy
+ let caller: T::AccountId = account("target", p - 1, SEED);
+ T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
  // ... and "real" is the traditional caller. This is not a typo.
  let real: T::AccountId = account("caller", 0, SEED);
+ add_announcements::<T>(T::MaxPending::get() - 1, Some(caller.clone()), None)?;
  let call: <T as Trait>::Call = frame_system::Call::<T>::remark(vec![]).into();
- }: _(RawOrigin::Signed(caller), real, Some(T::ProxyType::default()), Box::new(call))
+ let call_hash = T::CallHasher::hash_of(&call);
+ }: _(RawOrigin::Signed(caller.clone()), real.clone(), call_hash)
+ verify {
+ assert_last_event::<T>(RawEvent::Announced(real, caller, call_hash).into());
+ }
 
  add_proxy {
  let p in ...;
  let caller: T::AccountId = account("caller", 0, SEED);
- }: _(RawOrigin::Signed(caller), account("target", T::MaxProxies::get().into(), SEED), T::ProxyType::default())
+ }: _(
+ RawOrigin::Signed(caller.clone()),
+ account("target", T::MaxProxies::get().into(), SEED),
+ T::ProxyType::default(),
+ T::BlockNumber::zero()
+ )
+ verify {
+ let (proxies, _) = Proxies::<T>::get(caller);
+ assert_eq!(proxies.len() as u32, p + 1);
+ }
 
  remove_proxy {
  let p in ...;
  let caller: T::AccountId = account("caller", 0, SEED);
- }: _(RawOrigin::Signed(caller), account("target", 0, SEED), T::ProxyType::default())
+ }: _(
+ RawOrigin::Signed(caller.clone()),
+ account("target", 0, SEED),
+ T::ProxyType::default(),
+ T::BlockNumber::zero()
+ )
+ verify {
+ let (proxies, _) = Proxies::<T>::get(caller);
+ assert_eq!(proxies.len() as u32, p - 1);
+ }
 
  remove_proxies {
  let p in ...;
  let caller: T::AccountId = account("caller", 0, SEED);
- }: _(RawOrigin::Signed(caller))
+ }: _(RawOrigin::Signed(caller.clone()))
+ verify {
+ let (proxies, _) = Proxies::<T>::get(caller);
+ assert_eq!(proxies.len() as u32, 0);
+ }
 
  anonymous {
  let p in ...;
- }: _(RawOrigin::Signed(account("caller", 0, SEED)), T::ProxyType::default(), 0)
+ let caller: T::AccountId = account("caller", 0, SEED);
+ }: _(
+ RawOrigin::Signed(caller.clone()),
+ T::ProxyType::default(),
+ T::BlockNumber::zero(),
+ 0
+ )
+ verify {
+ let anon_account = Module::<T>::anonymous_account(&caller, &T::ProxyType::default(), 0, None);
+ assert_last_event::<T>(RawEvent::AnonymousCreated(
+ anon_account,
+ caller,
+ T::ProxyType::default(),
+ 0,
+ ).into());
+ }
 
  kill_anonymous {
  let p in 0 .. (T::MaxProxies::get() - 2).into();
 
  let caller: T::AccountId = account("caller", 0, SEED);
  T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
- Module::<T>::anonymous(RawOrigin::Signed(account("caller", 0, SEED)).into(), T::ProxyType::default(), 0)?;
+ Module::<T>::anonymous(
+ RawOrigin::Signed(account("caller", 0, SEED)).into(),
+ T::ProxyType::default(),
+ T::BlockNumber::zero(),
+ 0
+ )?;
  let height = system::Module::<T>::block_number();
  let ext_index = system::Module::<T>::extrinsic_index().unwrap_or(0);
  let anon = Module::<T>::anonymous_account(&caller, &T::ProxyType::default(), 0, None);
 
  add_proxies::<T>(p, Some(anon.clone()))?;
-
- }: _(RawOrigin::Signed(anon), caller, T::ProxyType::default(), 0, height, ext_index)
+ ensure!(Proxies::<T>::contains_key(&anon), "anon proxy not created");
+ }: _(RawOrigin::Signed(anon.clone()), caller.clone(), T::ProxyType::default(), 0, height, ext_index)
+ verify {
+ assert!(!Proxies::<T>::contains_key(&anon));
+ }
 }
 
 #[cfg(test)]
@@ -98,6 +261,10 @@ mod tests {
  fn test_benchmarks() {
  new_test_ext().execute_with(|| {
  assert_ok!(test_benchmark_proxy::<Test>());
+ assert_ok!(test_benchmark_proxy_announced::<Test>());
+ assert_ok!(test_benchmark_remove_announcement::<Test>());
+ assert_ok!(test_benchmark_reject_announcement::<Test>());
+ assert_ok!(test_benchmark_announce::<Test>());
  assert_ok!(test_benchmark_add_proxy::<Test>());
  assert_ok!(test_benchmark_remove_proxy::<Test>());
  assert_ok!(test_benchmark_remove_proxies::<Test>());