pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-13 05:51:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

BREAKING: Rename Origin (#12258)

Browse Source 
* BREAKING: Rename Origin

* more renaming

* a bit more renaming

* fix

* more fixing

* fix in frame_support

* even more fixes

* fix

* small fix

* ...

* update .stderr

* docs

* update docs

* update docs

* docs
This commit is contained in:
Sergej Sakac
2022-09-21 00:13:09 +02:00
committed by GitHub
parent 986d20b352
commit e4b6f4a66d
221 changed files with 5233 additions and 4200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/recovery/src/lib.rs
+1 -1
View File
@@ -232,7 +232,7 @@ pub mod pallet {
/// The overarching call type.
type RuntimeCall: Parameter
+ Dispatchable<Origin = Self::Origin, PostInfo = PostDispatchInfo>
+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+ GetDispatchInfo
+ From<frame_system::Call<Self>>;
substrate/frame/recovery/src/mock.rs
+1 -1
View File
@@ -55,7 +55,7 @@ impl frame_system::Config for Test {
type BlockWeights = ();
type BlockLength = ();
type DbWeight = ();
type Origin = Origin;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type Index = u64;
type BlockNumber = u64;
substrate/frame/recovery/src/tests.rs
+139 -87
View File
@@ -20,8 +20,8 @@
use super::*;
use frame_support::{assert_noop, assert_ok, bounded_vec, traits::Currency};
use mock::{
new_test_ext, run_to_block, Balances, BalancesCall, MaxFriends, Origin, Recovery, RecoveryCall,
RuntimeCall, Test,
new_test_ext, run_to_block, Balances, BalancesCall, MaxFriends, Recovery, RecoveryCall,
RuntimeCall, RuntimeOrigin, Test,
};
use sp_runtime::traits::BadOrigin;
@@ -41,12 +41,12 @@ fn basic_setup_works() {
fn set_recovered_works() {
new_test_ext().execute_with(|| {
// Not accessible by a normal user
assert_noop!(Recovery::set_recovered(Origin::signed(1), 5, 1), BadOrigin);
assert_noop!(Recovery::set_recovered(RuntimeOrigin::signed(1), 5, 1), BadOrigin);
// Root can set a recovered account though
assert_ok!(Recovery::set_recovered(Origin::root(), 5, 1));
assert_ok!(Recovery::set_recovered(RuntimeOrigin::root(), 5, 1));
// Account 1 should now be able to make a call through account 5
let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 1, value: 100 }));
assert_ok!(Recovery::as_recovered(Origin::signed(1), 5, call));
assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
// Account 1 has successfully drained the funds from account 5
assert_eq!(Balances::free_balance(1), 200);
assert_eq!(Balances::free_balance(5), 0);
@@ -60,38 +60,46 @@ fn recovery_life_cycle_works() {
let threshold = 3;
let delay_period = 10;
// Account 5 sets up a recovery configuration on their account
assert_ok!(Recovery::create_recovery(Origin::signed(5), friends, threshold, delay_period));
assert_ok!(Recovery::create_recovery(
RuntimeOrigin::signed(5),
friends,
threshold,
delay_period
));
// Some time has passed, and the user lost their keys!
run_to_block(10);
// Using account 1, the user begins the recovery process to recover the lost account
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
// Off chain, the user contacts their friends and asks them to vouch for the recovery
// attempt
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(Origin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(Origin::signed(4), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
// We met the threshold, lets try to recover the account...?
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::DelayPeriod);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::DelayPeriod
);
// We need to wait at least the delay_period number of blocks before we can recover
run_to_block(20);
assert_ok!(Recovery::claim_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::claim_recovery(RuntimeOrigin::signed(1), 5));
// Account 1 can use account 5 to close the active recovery process, claiming the deposited
// funds used to initiate the recovery process into account 5.
let call = Box::new(RuntimeCall::Recovery(RecoveryCall::close_recovery { rescuer: 1 }));
assert_ok!(Recovery::as_recovered(Origin::signed(1), 5, call));
assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
// Account 1 can then use account 5 to remove the recovery configuration, claiming the
// deposited funds used to create the recovery configuration into account 5.
let call = Box::new(RuntimeCall::Recovery(RecoveryCall::remove_recovery {}));
assert_ok!(Recovery::as_recovered(Origin::signed(1), 5, call));
assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
// Account 1 should now be able to make a call through account 5 to get all of their funds
assert_eq!(Balances::free_balance(5), 110);
let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer { dest: 1, value: 110 }));
assert_ok!(Recovery::as_recovered(Origin::signed(1), 5, call));
assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
// All funds have been fully recovered!
assert_eq!(Balances::free_balance(1), 200);
assert_eq!(Balances::free_balance(5), 0);
// Remove the proxy link.
assert_ok!(Recovery::cancel_recovered(Origin::signed(1), 5));
assert_ok!(Recovery::cancel_recovered(RuntimeOrigin::signed(1), 5));
// All storage items are removed from the module
assert!(!<ActiveRecoveries<Test>>::contains_key(&5, &1));
@@ -107,38 +115,52 @@ fn malicious_recovery_fails() {
let threshold = 3;
let delay_period = 10;
// Account 5 sets up a recovery configuration on their account
assert_ok!(Recovery::create_recovery(Origin::signed(5), friends, threshold, delay_period));
assert_ok!(Recovery::create_recovery(
RuntimeOrigin::signed(5),
friends,
threshold,
delay_period
));
// Some time has passed, and account 1 wants to try and attack this account!
run_to_block(10);
// Using account 1, the malicious user begins the recovery process on account 5
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
// Off chain, the user **tricks** their friends and asks them to vouch for the recovery
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
// shame on you
assert_ok!(Recovery::vouch_recovery(Origin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
// shame on you
assert_ok!(Recovery::vouch_recovery(Origin::signed(4), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
// shame on you
// We met the threshold, lets try to recover the account...?
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::DelayPeriod);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::DelayPeriod
);
// Account 1 needs to wait...
run_to_block(19);
// One more block to wait!
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::DelayPeriod);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::DelayPeriod
);
// Account 5 checks their account every `delay_period` and notices the malicious attack!
// Account 5 can close the recovery process before account 1 can claim it
assert_ok!(Recovery::close_recovery(Origin::signed(5), 1));
assert_ok!(Recovery::close_recovery(RuntimeOrigin::signed(5), 1));
// By doing so, account 5 has now claimed the deposit originally reserved by account 1
assert_eq!(Balances::total_balance(&1), 90);
// Thanks for the free money!
assert_eq!(Balances::total_balance(&5), 110);
// The recovery process has been closed, so account 1 can't make the claim
run_to_block(20);
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::NotStarted);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::NotStarted
);
// Account 5 can remove their recovery config and pick some better friends
assert_ok!(Recovery::remove_recovery(Origin::signed(5)));
assert_ok!(Recovery::remove_recovery(RuntimeOrigin::signed(5)));
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
vec![22, 33, 44],
threshold,
delay_period
@@ -151,23 +173,23 @@ fn create_recovery_handles_basic_errors() {
new_test_ext().execute_with(|| {
// No friends
assert_noop!(
Recovery::create_recovery(Origin::signed(5), vec![], 1, 0),
Recovery::create_recovery(RuntimeOrigin::signed(5), vec![], 1, 0),
Error::<Test>::NotEnoughFriends
);
// Zero threshold
assert_noop!(
Recovery::create_recovery(Origin::signed(5), vec![2], 0, 0),
Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2], 0, 0),
Error::<Test>::ZeroThreshold
);
// Threshold greater than friends length
assert_noop!(
Recovery::create_recovery(Origin::signed(5), vec![2, 3, 4], 4, 0),
Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 3, 4], 4, 0),
Error::<Test>::NotEnoughFriends
);
// Too many friends
assert_noop!(
Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
vec![1; (MaxFriends::get() + 1) as usize],
1,
0
@@ -176,18 +198,18 @@ fn create_recovery_handles_basic_errors() {
);
// Unsorted friends
assert_noop!(
Recovery::create_recovery(Origin::signed(5), vec![3, 2, 4], 3, 0),
Recovery::create_recovery(RuntimeOrigin::signed(5), vec![3, 2, 4], 3, 0),
Error::<Test>::NotSorted
);
// Duplicate friends
assert_noop!(
Recovery::create_recovery(Origin::signed(5), vec![2, 2, 4], 3, 0),
Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 2, 4], 3, 0),
Error::<Test>::NotSorted
);
// Already configured
assert_ok!(Recovery::create_recovery(Origin::signed(5), vec![2, 3, 4], 3, 10));
assert_ok!(Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 3, 4], 3, 10));
assert_noop!(
Recovery::create_recovery(Origin::signed(5), vec![2, 3, 4], 3, 10),
Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 3, 4], 3, 10),
Error::<Test>::AlreadyRecoverable
);
});
@@ -201,7 +223,7 @@ fn create_recovery_works() {
let delay_period = 10;
// Account 5 sets up a recovery configuration on their account
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
@@ -225,7 +247,7 @@ fn initiate_recovery_handles_basic_errors() {
new_test_ext().execute_with(|| {
// No recovery process set up for the account
assert_noop!(
Recovery::initiate_recovery(Origin::signed(1), 5),
Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::NotRecoverable
);
// Create a recovery process for next test
@@ -233,15 +255,15 @@ fn initiate_recovery_handles_basic_errors() {
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
// Same user cannot recover same account twice
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
assert_noop!(
Recovery::initiate_recovery(Origin::signed(1), 5),
Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::AlreadyStarted
);
// No double deposit
@@ -257,13 +279,13 @@ fn initiate_recovery_works() {
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
// Recovery can be initiated
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
// Deposit is reserved
assert_eq!(Balances::reserved_balance(1), 10);
// Recovery status object is created correctly
@@ -271,7 +293,7 @@ fn initiate_recovery_works() {
ActiveRecovery { created: 0, deposit: 10, friends: Default::default() };
assert_eq!(<ActiveRecoveries<Test>>::get(&5, &1), Some(recovery_status));
// Multiple users can attempt to recover the same account
assert_ok!(Recovery::initiate_recovery(Origin::signed(2), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(2), 5));
});
}
@@ -280,7 +302,7 @@ fn vouch_recovery_handles_basic_errors() {
new_test_ext().execute_with(|| {
// Cannot vouch for non-recoverable account
assert_noop!(
Recovery::vouch_recovery(Origin::signed(2), 5, 1),
Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1),
Error::<Test>::NotRecoverable
);
// Create a recovery process for next tests
@@ -288,21 +310,27 @@ fn vouch_recovery_handles_basic_errors() {
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
// Cannot vouch a recovery process that has not started
assert_noop!(Recovery::vouch_recovery(Origin::signed(2), 5, 1), Error::<Test>::NotStarted);
// Initiate a recovery process
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
// Cannot vouch if you are not a friend
assert_noop!(Recovery::vouch_recovery(Origin::signed(22), 5, 1), Error::<Test>::NotFriend);
// Cannot vouch twice
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 1));
assert_noop!(
Recovery::vouch_recovery(Origin::signed(2), 5, 1),
Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1),
Error::<Test>::NotStarted
);
// Initiate a recovery process
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
// Cannot vouch if you are not a friend
assert_noop!(
Recovery::vouch_recovery(RuntimeOrigin::signed(22), 5, 1),
Error::<Test>::NotFriend
);
// Cannot vouch twice
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
assert_noop!(
Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1),
Error::<Test>::AlreadyVouched
);
});
@@ -316,17 +344,17 @@ fn vouch_recovery_works() {
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
// Vouching works
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
// Handles out of order vouches
assert_ok!(Recovery::vouch_recovery(Origin::signed(4), 5, 1));
assert_ok!(Recovery::vouch_recovery(Origin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
// Final recovery status object is updated correctly
let recovery_status =
ActiveRecovery { created: 0, deposit: 10, friends: bounded_vec![2, 3, 4] };
@@ -338,28 +366,40 @@ fn vouch_recovery_works() {
fn claim_recovery_handles_basic_errors() {
new_test_ext().execute_with(|| {
// Cannot claim a non-recoverable account
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::NotRecoverable);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::NotRecoverable
);
// Create a recovery process for the test
let friends = vec![2, 3, 4];
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
// Cannot claim an account which has not started the recovery process
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::NotStarted);
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::NotStarted
);
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
// Cannot claim an account which has not passed the delay period
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::DelayPeriod);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::DelayPeriod
);
run_to_block(11);
// Cannot claim an account which has not passed the threshold number of votes
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(Origin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
// Only 2/3 is not good enough
assert_noop!(Recovery::claim_recovery(Origin::signed(1), 5), Error::<Test>::Threshold);
assert_noop!(
Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
Error::<Test>::Threshold
);
});
}
@@ -371,32 +411,32 @@ fn claim_recovery_works() {
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(Origin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(Origin::signed(4), 5, 1));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
run_to_block(11);
// Account can be recovered.
assert_ok!(Recovery::claim_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::claim_recovery(RuntimeOrigin::signed(1), 5));
// Recovered storage item is correctly created
assert_eq!(<Proxy<Test>>::get(&1), Some(5));
// Account could be re-recovered in the case that the recoverer account also gets lost.
assert_ok!(Recovery::initiate_recovery(Origin::signed(4), 5));
assert_ok!(Recovery::vouch_recovery(Origin::signed(2), 5, 4));
assert_ok!(Recovery::vouch_recovery(Origin::signed(3), 5, 4));
assert_ok!(Recovery::vouch_recovery(Origin::signed(4), 5, 4));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(4), 5));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 4));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 4));
assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 4));
run_to_block(21);
// Account is re-recovered.
assert_ok!(Recovery::claim_recovery(Origin::signed(4), 5));
assert_ok!(Recovery::claim_recovery(RuntimeOrigin::signed(4), 5));
// Recovered storage item is correctly updated
assert_eq!(<Proxy<Test>>::get(&4), Some(5));
});
@@ -406,7 +446,10 @@ fn claim_recovery_works() {
fn close_recovery_handles_basic_errors() {
new_test_ext().execute_with(|| {
// Cannot close a non-active recovery
assert_noop!(Recovery::close_recovery(Origin::signed(5), 1), Error::<Test>::NotStarted);
assert_noop!(
Recovery::close_recovery(RuntimeOrigin::signed(5), 1),
Error::<Test>::NotStarted
);
});
}
@@ -414,26 +457,35 @@ fn close_recovery_handles_basic_errors() {
fn remove_recovery_works() {
new_test_ext().execute_with(|| {
// Cannot remove an unrecoverable account
assert_noop!(Recovery::remove_recovery(Origin::signed(5)), Error::<Test>::NotRecoverable);
assert_noop!(
Recovery::remove_recovery(RuntimeOrigin::signed(5)),
Error::<Test>::NotRecoverable
);
// Create and initiate a recovery process for the test
let friends = vec![2, 3, 4];
let threshold = 3;
let delay_period = 10;
assert_ok!(Recovery::create_recovery(
Origin::signed(5),
RuntimeOrigin::signed(5),
friends.clone(),
threshold,
delay_period
));
assert_ok!(Recovery::initiate_recovery(Origin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(Origin::signed(2), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(2), 5));
// Cannot remove a recovery when there are active recoveries.
assert_noop!(Recovery::remove_recovery(Origin::signed(5)), Error::<Test>::StillActive);
assert_ok!(Recovery::close_recovery(Origin::signed(5), 1));
assert_noop!(
Recovery::remove_recovery(RuntimeOrigin::signed(5)),
Error::<Test>::StillActive
);
assert_ok!(Recovery::close_recovery(RuntimeOrigin::signed(5), 1));
// Still need to remove one more!
assert_noop!(Recovery::remove_recovery(Origin::signed(5)), Error::<Test>::StillActive);
assert_ok!(Recovery::close_recovery(Origin::signed(5), 2));
assert_noop!(
Recovery::remove_recovery(RuntimeOrigin::signed(5)),
Error::<Test>::StillActive
);
assert_ok!(Recovery::close_recovery(RuntimeOrigin::signed(5), 2));
// Finally removed
assert_ok!(Recovery::remove_recovery(Origin::signed(5)));
assert_ok!(Recovery::remove_recovery(RuntimeOrigin::signed(5)));
});
}