Add force remove vesting

substrate/frame/support/src/storage/generator/double_map.rs

@@ -147,7 +147,6 @@ where
  {
  unhashed::get(&Self::storage_double_map_final_key(k1, k2)).ok_or(())
  }
-
  fn set<KArg1: EncodeLike<K1>, KArg2: EncodeLike<K2>>(k1: KArg1, k2: KArg2, q: Self::Query) {
  match G::from_query_to_optional_value(q) {
  Some(v) => Self::insert(k1, k2, v),

substrate/frame/vesting/src/benchmarking.rs

@@ -271,6 +271,52 @@ benchmarks! {
  );
  }
 
+ force_remove_vesting_schedule {
+ let l in 0 .. MaxLocksOf::<T>::get() - 1;
+ let s in 2 .. T::MAX_VESTING_SCHEDULES;
+
+ let source: T::AccountId = account("source", 0, SEED);
+ let source_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(source.clone());
+ T::Currency::make_free_balance_be(&source, BalanceOf::<T>::max_value());
+
+ let target: T::AccountId = account("target", 0, SEED);
+ let target_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(target.clone());
+
+ assert!(l <= u8::MAX.into());
+ // Give target existing locks.
+ add_locks::<T>(&target, l as u8);
+
+ let transfer_amount = T::MinVestedTransfer::get();
+ let per_block = transfer_amount.checked_div(&20u32.into()).unwrap();
+
+ let number_of_schedules_after_removal = T::MAX_VESTING_SCHEDULES - 1;
+ let expected_balance = transfer_amount.checked_mul(&number_of_schedules_after_removal.into()).unwrap();
+
+ // It will remove last vesting schedule.
+ let schedule_index = T::MAX_VESTING_SCHEDULES - 1;
+
+ let vesting_schedule = VestingInfo::new(
+ transfer_amount,
+ per_block,
+ 1u32.into(),
+ );
+
+ for _ in 0..s {
+ assert_ok!(Vesting::<T>::do_vested_transfer(
+ source_lookup.clone(),
+ target_lookup.clone(),
+ vesting_schedule.into()
+ ));
+ }
+ }: _(RawOrigin::Root, target_lookup, schedule_index)
+ verify {
+ assert_eq!(
+ Vesting::<T>::vesting_balance(&target),
+ Some(expected_balance),
+ "Vesting schedule was not removed",
+ );
+ }
+
  not_unlocking_merge_schedules {
  let l in 0 .. MaxLocksOf::<T>::get() - 1;
  let s in 2 .. T::MAX_VESTING_SCHEDULES;

substrate/frame/vesting/src/lib.rs

@@ -378,6 +378,25 @@ pub mod pallet {
  Self::do_vested_transfer(source, target, schedule)
  }
 
+ /// Force remove a vesting schedule
+ ///
+ /// The dispatch origin for this call must be _Root_.
+ ///
+ /// - `target`: An account that has a vesting schedule
+ /// - `schedule_index`: The vesting schedule index that should be removed
+ #[pallet::weight(
+ T::WeightInfo::force_remove_vesting_schedule(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES)
+ )]
+ pub fn force_remove_vesting_schedule(
+ origin: OriginFor<T>,
+ target: <T::Lookup as StaticLookup>::Source,
+ schedule_index: u32,
+ ) -> DispatchResult {
+ ensure_root(origin)?;
+ let who = T::Lookup::lookup(target)?;
+ Self::remove_vesting_schedule(&who, schedule_index)
+ }
+
  /// Merge two vesting schedules together, creating a new vesting schedule that unlocks over
  /// the highest possible start and end blocks. If both schedules have already started the
  /// current block will be used as the schedule start; with the caveat that if one schedule

substrate/frame/vesting/src/tests.rs

@@ -1155,3 +1155,42 @@ fn vested_transfer_less_than_existential_deposit_fails() {
  );
  });
 }
+
+
+#[test]
+fn remove_vesting_schedule() {
+ ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+ let user3_free_balance = Balances::free_balance(&3);
+ let user4_free_balance = Balances::free_balance(&4);
+ assert_eq!(user3_free_balance, 256 * 30);
+ assert_eq!(user4_free_balance, 256 * 40);
+ // Account 4 should not have any vesting yet.
+ assert_eq!(Vesting::vesting(&4), None);
+ // Make the schedule for the new transfer.
+ let new_vesting_schedule = VestingInfo::new(
+ ED * 5,
+ (ED * 5) / 20, // Vesting over 20 blocks
+ 10,
+ );
+ assert_ok!(Vesting::vested_transfer(Some(3).into(), 4, new_vesting_schedule));
+ // Now account 4 should have vesting.
+ assert_eq!(Vesting::vesting(&4).unwrap(), vec![new_vesting_schedule]);
+ // Account 4 has 5 * 256 locked.
+ assert_eq!(Vesting::vesting_balance(&4), Some(256 * 5));
+ // Verify only root can call.
+ assert_noop!(Vesting::force_remove_vesting_schedule(Some(4).into(), 4, 0), BadOrigin);
+ // Verify that root can remove the schedule.
+ assert_ok!(Vesting::force_remove_vesting_schedule(RawOrigin::Root.into(), 4, 0));
+// Verify that last event is VestingCompleted.
+ System::assert_last_event(Event::VestingCompleted { account: 4 }.into());
+ // Appropriate storage is cleaned up.
+ assert!(!<VestingStorage<Test>>::contains_key(4));
+ // Check the vesting balance is zero.
+ assert_eq!(Vesting::vesting(&4), None);
+ // Verifies that trying to remove a schedule when it doesnt exist throws error.
+ assert_noop!(
+ Vesting::force_remove_vesting_schedule(RawOrigin::Root.into(), 4, 0),
+ Error::<Test>::NotVesting
+ );
+ });
+}