Skip to content

Commit 8391945

Browse files
l0r1sl0r1s
committed
reinstate swap_coldkey call + add call to remove announcement as root
1 parent 184c8d4 commit 8391945

File tree

6 files changed

+123
-74
lines changed

6 files changed

+123
-74
lines changed

‎pallets/admin-utils/src/lib.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2199,7 +2199,7 @@ pub mod pallet {
21992199
) -> DispatchResult {
22002200
ensure_root(origin)?;
22012201
pallet_subtensor::Pallet::<T>::set_coldkey_swap_announcement_delay(duration);
2202-
log::trace!("ColdkeySwapScheduleDurationSet( duration: {duration:?} )");
2202+
log::trace!("ColdkeySwapAnnouncementDelaySet( duration: {duration:?} )");
22032203
Ok(())
22042204
}
22052205
}

‎pallets/subtensor/src/macros/dispatches.rs‎

Lines changed: 32 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1065,19 +1065,24 @@ mod dispatches {
10651065
Self::do_swap_hotkey(origin, &hotkey, &new_hotkey, netuid)
10661066
}
10671067

1068-
/// The extrinsic for user to change the coldkey associated with their account.
1068+
/// Performs an arbitrary coldkey swap for any coldkey.
10691069
///
1070-
/// WARNING: This is deprecated in favor of `announce_coldkey_swap`/`coldkey_swap`
1070+
/// Only callable by root as it doesn't require an announcement and can be used to swap any coldkey.
10711071
#[pallet::call_index(71)]
10721072
#[pallet::weight(Weight::zero())]
1073-
#[deprecated(note = "Deprecated, please migrate to `announce_coldkey_swap`/`coldkey_swap`")]
10741073
pub fn swap_coldkey(
1075-
_origin: OriginFor<T>,
1076-
_old_coldkey: T::AccountId,
1077-
_new_coldkey: T::AccountId,
1078-
_swap_cost: TaoCurrency,
1074+
origin: OriginFor<T>,
1075+
old_coldkey: T::AccountId,
1076+
new_coldkey: T::AccountId,
1077+
swap_cost: TaoCurrency,
10791078
) -> DispatchResult {
1080-
Err(Error::<T>::Deprecated.into())
1079+
ensure_root(origin)?;
1080+
1081+
Self::do_swap_coldkey(&old_coldkey, &new_coldkey, swap_cost)?;
1082+
// We also remove any announcement for security reasons
1083+
ColdkeySwapAnnouncements::<T>::remove(old_coldkey);
1084+
1085+
Ok(())
10811086
}
10821087

10831088
/// Sets the childkey take for a given hotkey.
@@ -2351,7 +2356,7 @@ mod dispatches {
23512356
let when = existing.0;
23522357
ensure!(
23532358
now > when.saturating_add(delay),
2354-
Error::<T>::ColdKeySwapReannouncedTooEarly
2359+
Error::<T>::ColdkeySwapReannouncedTooEarly
23552360
);
23562361
}
23572362

@@ -2376,7 +2381,7 @@ mod dispatches {
23762381
let who = ensure_signed(origin)?;
23772382

23782383
let (when, new_coldkey_hash) = ColdkeySwapAnnouncements::<T>::take(who.clone())
2379-
.ok_or(Error::<T>::ColdKeySwapAnnouncementNotFound)?;
2384+
.ok_or(Error::<T>::ColdkeySwapAnnouncementNotFound)?;
23802385

23812386
ensure!(
23822387
new_coldkey_hash == T::Hashing::hash_of(&new_coldkey),
@@ -2387,12 +2392,27 @@ mod dispatches {
23872392
let delay = ColdkeySwapAnnouncementDelay::<T>::get();
23882393
ensure!(
23892394
now > when.saturating_add(delay),
2390-
Error::<T>::ColdKeySwapTooEarly
2395+
Error::<T>::ColdkeySwapTooEarly
23912396
);
23922397

2393-
Self::do_swap_coldkey(&who, &new_coldkey)?;
2398+
let swap_cost = Self::get_key_swap_cost();
2399+
Self::do_swap_coldkey(&who, &new_coldkey, swap_cost)?;
23942400

23952401
Ok(())
23962402
}
2403+
2404+
/// Removes a coldkey swap announcement for a coldkey.
2405+
///
2406+
/// Only callable by root.
2407+
#[pallet::call_index(127)]
2408+
#[pallet::weight(Weight::zero())]
2409+
pub fn remove_coldkey_swap_announcement(
2410+
origin: OriginFor<T>,
2411+
coldkey: T::AccountId,
2412+
) -> DispatchResult {
2413+
ensure_root(origin)?;
2414+
ColdkeySwapAnnouncements::<T>::remove(coldkey);
2415+
Ok(())
2416+
}
23972417
}
23982418
}

‎pallets/subtensor/src/macros/errors.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -149,11 +149,11 @@ mod errors {
149149
/// Default transaction rate limit exceeded.
150150
TxRateLimitExceeded,
151151
/// Coldkey swap announcement not found
152-
ColdKeySwapAnnouncementNotFound,
152+
ColdkeySwapAnnouncementNotFound,
153153
/// Coldkey swap too early.
154-
ColdKeySwapTooEarly,
154+
ColdkeySwapTooEarly,
155155
/// Coldkey swap reannounced too early.
156-
ColdKeySwapReannouncedTooEarly,
156+
ColdkeySwapReannouncedTooEarly,
157157
/// The announced coldkey hash does not match the new coldkey hash.
158158
AnnouncedColdkeyHashDoesNotMatch,
159159
/// New coldkey is hotkey

‎pallets/subtensor/src/swap/swap_coldkey.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ impl<T: Config> Pallet<T> {
77
pub fn do_swap_coldkey(
88
old_coldkey: &T::AccountId,
99
new_coldkey: &T::AccountId,
10+
swap_cost: TaoCurrency,
1011
) -> DispatchResult {
1112
ensure!(
1213
StakingHotkeys::<T>::get(new_coldkey).is_empty(),
@@ -18,7 +19,6 @@ impl<T: Config> Pallet<T> {
1819
);
1920

2021
// Remove and recycle the swap cost from the old coldkey's account
21-
let swap_cost = Self::get_key_swap_cost();
2222
ensure!(
2323
Self::can_remove_balance_from_coldkey_account(old_coldkey, swap_cost.into()),
2424
Error::<T>::NotEnoughBalanceToPaySwapColdKey

‎pallets/subtensor/src/tests/claim_root.rs‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1184,9 +1184,11 @@ fn test_claim_root_with_swap_coldkey() {
11841184
);
11851185

11861186
// Swap coldkey
1187-
let swap_cost = SubtensorModule::get_key_swap_cost();
1188-
SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost.to_u64());
1189-
assert_ok!(SubtensorModule::do_swap_coldkey(&coldkey, &new_coldkey,));
1187+
assert_ok!(SubtensorModule::do_swap_coldkey(
1188+
&coldkey,
1189+
&new_coldkey,
1190+
TaoCurrency::ZERO
1191+
));
11901192

11911193
// Check swapped keys claimed values
11921194

‎pallets/subtensor/src/tests/swap_coldkey.rs‎

Lines changed: 81 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -142,7 +142,7 @@ fn test_announce_coldkey_swap_with_existing_announcement_not_past_delay_fails()
142142

143143
assert_noop!(
144144
SubtensorModule::announce_coldkey_swap(RuntimeOrigin::signed(who), new_coldkey_2_hash,),
145-
Error::<Test>::ColdKeySwapReannouncedTooEarly
145+
Error::<Test>::ColdkeySwapReannouncedTooEarly
146146
);
147147
});
148148
}
@@ -266,7 +266,7 @@ fn test_swap_coldkey_announced_works() {
266266
));
267267

268268
// Ensure the announcement has been consumed
269-
assert_eq!(ColdkeySwapAnnouncements::<Test>::get(who), None);
269+
assert_eq!(!ColdkeySwapAnnouncements::<Test>::contains_key(who));
270270

271271
// Ensure the cost has been withdrawn from the old coldkey and recycled
272272
let balance_after = SubtensorModule::get_coldkey_balance(&who);
@@ -404,10 +404,11 @@ fn test_do_swap_coldkey_preserves_new_coldkey_identity() {
404404
};
405405
IdentitiesV2::<Test>::insert(new_coldkey, new_identity.clone());
406406

407-
let swap_cost = SubtensorModule::get_key_swap_cost();
408-
SubtensorModule::add_balance_to_coldkey_account(&who, swap_cost.to_u64());
409-
410-
assert_ok!(SubtensorModule::do_swap_coldkey(&who, &new_coldkey));
407+
assert_ok!(SubtensorModule::do_swap_coldkey(
408+
&who,
409+
&new_coldkey,
410+
TaoCurrency::ZERO
411+
));
411412

412413
// Identity is preserved
413414
assert_eq!(IdentitiesV2::<Test>::get(who), Some(old_identity));
@@ -441,7 +442,7 @@ fn test_swap_coldkey_announced_without_announcement_fails() {
441442

442443
assert_noop!(
443444
SubtensorModule::swap_coldkey_announced(RuntimeOrigin::signed(who), new_coldkey),
444-
Error::<Test>::ColdKeySwapAnnouncementNotFound
445+
Error::<Test>::ColdkeySwapAnnouncementNotFound
445446
);
446447
})
447448
}
@@ -483,7 +484,7 @@ fn test_swap_coldkey_announced_too_early_fails() {
483484
<Test as frame_system::Config>::RuntimeOrigin::signed(who),
484485
new_coldkey
485486
),
486-
Error::<Test>::ColdKeySwapTooEarly
487+
Error::<Test>::ColdkeySwapTooEarly
487488
);
488489
})
489490
}
@@ -562,8 +563,9 @@ fn test_do_swap_coldkey_with_not_enough_balance_to_pay_swap_cost_fails() {
562563
let delay = ColdkeySwapAnnouncementDelay::<Test>::get() + 1;
563564
System::run_to_block::<AllPalletsWithSystem>(now + delay);
564565

566+
let swap_cost = SubtensorModule::get_key_swap_cost();
565567
assert_noop!(
566-
SubtensorModule::do_swap_coldkey(&who, &new_coldkey),
568+
SubtensorModule::do_swap_coldkey(&who, &new_coldkey, swap_cost),
567569
Error::<Test>::NotEnoughBalanceToPaySwapColdKey
568570
);
569571
});
@@ -575,10 +577,11 @@ fn test_do_swap_coldkey_with_no_stake() {
575577
let old_coldkey = U256::from(1);
576578
let new_coldkey = U256::from(2);
577579

578-
let swap_cost = SubtensorModule::get_key_swap_cost();
579-
SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, swap_cost.to_u64());
580-
581-
assert_ok!(SubtensorModule::do_swap_coldkey(&old_coldkey, &new_coldkey,));
580+
assert_ok!(SubtensorModule::do_swap_coldkey(
581+
&old_coldkey,
582+
&new_coldkey,
583+
TaoCurrency::ZERO
584+
));
582585

583586
assert_eq!(
584587
SubtensorModule::get_total_stake_for_coldkey(&old_coldkey),
@@ -648,14 +651,15 @@ fn test_do_swap_coldkey_with_max_values() {
648651
netuid2,
649652
);
650653

651-
let swap_cost = SubtensorModule::get_key_swap_cost();
652-
SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, swap_cost.to_u64());
653-
SubtensorModule::add_balance_to_coldkey_account(&old_coldkey2, swap_cost.to_u64());
654-
655-
assert_ok!(SubtensorModule::do_swap_coldkey(&old_coldkey, &new_coldkey,));
654+
assert_ok!(SubtensorModule::do_swap_coldkey(
655+
&old_coldkey,
656+
&new_coldkey,
657+
TaoCurrency::ZERO
658+
));
656659
assert_ok!(SubtensorModule::do_swap_coldkey(
657660
&old_coldkey2,
658-
&new_coldkey2
661+
&new_coldkey2,
662+
TaoCurrency::ZERO
659663
));
660664

661665
assert_eq!(
@@ -713,10 +717,11 @@ fn test_do_swap_coldkey_effect_on_delegated_stake() {
713717
let coldkey_stake_before = SubtensorModule::get_total_stake_for_coldkey(&old_coldkey);
714718
let delegator_stake_before = SubtensorModule::get_total_stake_for_coldkey(&delegator);
715719

716-
let swap_cost = SubtensorModule::get_key_swap_cost();
717-
SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, swap_cost.to_u64());
718-
719-
assert_ok!(SubtensorModule::do_swap_coldkey(&old_coldkey, &new_coldkey,));
720+
assert_ok!(SubtensorModule::do_swap_coldkey(
721+
&old_coldkey,
722+
&new_coldkey,
723+
TaoCurrency::ZERO
724+
));
720725

721726
assert_abs_diff_eq!(
722727
SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
@@ -808,11 +813,12 @@ fn test_swap_delegated_stake_for_coldkey() {
808813
let total_hotkey1_stake = SubtensorModule::get_total_stake_for_hotkey(&hotkey1);
809814
let total_hotkey2_stake = SubtensorModule::get_total_stake_for_hotkey(&hotkey2);
810815

811-
let swap_cost = SubtensorModule::get_key_swap_cost();
812-
SubtensorModule::add_balance_to_coldkey_account(&old_coldkey, swap_cost.to_u64());
813-
814816
// Perform the swap
815-
assert_ok!(SubtensorModule::do_swap_coldkey(&old_coldkey, &new_coldkey,));
817+
assert_ok!(SubtensorModule::do_swap_coldkey(
818+
&old_coldkey,
819+
&new_coldkey,
820+
TaoCurrency::ZERO
821+
));
816822

817823
// Verify stake transfer
818824
assert_eq!(
@@ -1100,16 +1106,17 @@ fn test_coldkey_swap_total() {
11001106
vec![hotkey3, delegate3]
11011107
);
11021108

1103-
let swap_cost = SubtensorModule::get_key_swap_cost();
1104-
SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost.to_u64());
1105-
11061109
// Perform the swap
11071110
let new_coldkey = U256::from(1100);
11081111
assert_eq!(
11091112
SubtensorModule::get_total_stake_for_coldkey(&coldkey),
11101113
ck_stake
11111114
);
1112-
assert_ok!(SubtensorModule::do_swap_coldkey(&coldkey, &new_coldkey,));
1115+
assert_ok!(SubtensorModule::do_swap_coldkey(
1116+
&coldkey,
1117+
&new_coldkey,
1118+
TaoCurrency::ZERO
1119+
));
11131120
assert_eq!(
11141121
SubtensorModule::get_total_stake_for_coldkey(&new_coldkey),
11151122
ck_stake
@@ -1243,11 +1250,12 @@ fn test_do_swap_coldkey_effect_on_delegations() {
12431250
stake.into()
12441251
));
12451252

1246-
let swap_cost = SubtensorModule::get_key_swap_cost();
1247-
SubtensorModule::add_balance_to_coldkey_account(&coldkey, swap_cost.to_u64());
1248-
12491253
// Perform the swap
1250-
assert_ok!(SubtensorModule::do_swap_coldkey(&coldkey, &new_coldkey,));
1254+
assert_ok!(SubtensorModule::do_swap_coldkey(
1255+
&coldkey,
1256+
&new_coldkey,
1257+
TaoCurrency::ZERO
1258+
));
12511259

12521260
// Verify stake was moved for the delegate
12531261
let approx_total_stake = TaoCurrency::from(stake * 2 - fee * 2);
@@ -1283,6 +1291,44 @@ fn test_do_swap_coldkey_effect_on_delegations() {
12831291
});
12841292
}
12851293

1294+
#[test]
1295+
fn test_remove_coldkey_swap_announcement_works() {
1296+
new_test_ext(1).execute_with(|| {
1297+
let who = U256::from(1);
1298+
let new_coldkey = U256::from(2);
1299+
let new_coldkey_hash = <Test as frame_system::Config>::Hashing::hash_of(&new_coldkey);
1300+
1301+
assert_ok!(SubtensorModule::announce_coldkey_swap(
1302+
RuntimeOrigin::signed(who),
1303+
new_coldkey_hash,
1304+
));
1305+
1306+
assert_ok!(SubtensorModule::remove_coldkey_swap_announcement(
1307+
RuntimeOrigin::root(),
1308+
who,
1309+
));
1310+
1311+
assert!(!ColdkeySwapAnnouncements::<Test>::contains_key(who));
1312+
});
1313+
}
1314+
1315+
#[test]
1316+
fn test_remove_coldkey_swap_announcement_with_bad_origin_fails() {
1317+
new_test_ext(1).execute_with(|| {
1318+
let who = U256::from(1);
1319+
1320+
assert_noop!(
1321+
SubtensorModule::remove_coldkey_swap_announcement(RuntimeOrigin::none(), who),
1322+
BadOrigin
1323+
);
1324+
1325+
assert_noop!(
1326+
SubtensorModule::remove_coldkey_swap_announcement(RuntimeOrigin::root(), who),
1327+
BadOrigin
1328+
);
1329+
});
1330+
}
1331+
12861332
#[test]
12871333
fn test_subtensor_extension_rejects_any_call_that_is_not_swap_coldkey_announced() {
12881334
new_test_ext(0).execute_with(|| {
@@ -1401,25 +1447,6 @@ fn test_subtensor_extension_rejects_any_call_that_is_not_swap_coldkey_announced(
14011447
});
14021448
}
14031449

1404-
#[test]
1405-
#[allow(deprecated)]
1406-
fn test_swap_coldkey_deprecated() {
1407-
new_test_ext(1).execute_with(|| {
1408-
let old_coldkey = U256::from(1);
1409-
let new_coldkey = U256::from(2);
1410-
1411-
assert_noop!(
1412-
SubtensorModule::swap_coldkey(
1413-
<<Test as Config>::RuntimeOrigin>::root(),
1414-
old_coldkey,
1415-
new_coldkey,
1416-
TaoCurrency::MAX
1417-
),
1418-
Error::<Test>::Deprecated
1419-
);
1420-
});
1421-
}
1422-
14231450
#[test]
14241451
#[allow(deprecated)]
14251452
fn test_schedule_swap_coldkey_deprecated() {

0 commit comments

Comments
 (0)