@@ -934,47 +934,48 @@ fn test_get_root_children_drain() {
934
934
// Set TAO weight to 1.
935
935
SubtensorModule :: set_tao_weight ( u64:: MAX ) ; // Set TAO weight to 1.
936
936
// Create keys.
937
- let cold = U256 :: from ( 0 ) ;
938
- let alice = U256 :: from ( 1 ) ;
939
- let bob = U256 :: from ( 2 ) ;
937
+ let cold_alice = U256 :: from ( 0 ) ;
938
+ let cold_bob = U256 :: from ( 1 ) ;
939
+ let alice = U256 :: from ( 2 ) ;
940
+ let bob = U256 :: from ( 3 ) ;
940
941
// Register Alice and Bob to the root network and alpha subnet.
941
- register_ok_neuron ( alpha, alice, cold , 0 ) ;
942
- register_ok_neuron ( alpha, bob, cold , 0 ) ;
942
+ register_ok_neuron ( alpha, alice, cold_alice , 0 ) ;
943
+ register_ok_neuron ( alpha, bob, cold_bob , 0 ) ;
943
944
assert_ok ! ( SubtensorModule :: root_register(
944
- RuntimeOrigin :: signed( cold ) . clone( ) ,
945
+ RuntimeOrigin :: signed( cold_alice ) . clone( ) ,
945
946
alice,
946
947
) ) ;
947
948
assert_ok ! ( SubtensorModule :: root_register(
948
- RuntimeOrigin :: signed( cold ) . clone( ) ,
949
+ RuntimeOrigin :: signed( cold_bob ) . clone( ) ,
949
950
bob,
950
951
) ) ;
951
952
// Add stake for Alice and Bob on root.
952
953
let alice_root_stake: u64 = 1_000_000_000 ;
953
954
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
954
955
& alice,
955
- & cold ,
956
+ & cold_alice ,
956
957
root,
957
958
alice_root_stake,
958
959
) ;
959
960
let bob_root_stake: u64 = 1_000_000_000 ;
960
961
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
961
962
& bob,
962
- & cold ,
963
+ & cold_bob ,
963
964
root,
964
965
alice_root_stake,
965
966
) ;
966
967
// Add stake for Alice and Bob on netuid.
967
968
let alice_alpha_stake: u64 = 1_000_000_000 ;
968
969
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
969
970
& alice,
970
- & cold ,
971
+ & cold_alice ,
971
972
alpha,
972
973
alice_alpha_stake,
973
974
) ;
974
975
let bob_alpha_stake: u64 = 1_000_000_000 ;
975
976
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
976
977
& bob,
977
- & cold ,
978
+ & cold_bob ,
978
979
alpha,
979
980
bob_alpha_stake,
980
981
) ;
@@ -1056,47 +1057,48 @@ fn test_get_root_children_drain_half_proportion() {
1056
1057
// Set TAO weight to 1.
1057
1058
SubtensorModule :: set_tao_weight ( u64:: MAX ) ; // Set TAO weight to 1.
1058
1059
// Create keys.
1059
- let cold = U256 :: from ( 0 ) ;
1060
- let alice = U256 :: from ( 1 ) ;
1061
- let bob = U256 :: from ( 2 ) ;
1060
+ let cold_alice = U256 :: from ( 0 ) ;
1061
+ let cold_bob = U256 :: from ( 1 ) ;
1062
+ let alice = U256 :: from ( 2 ) ;
1063
+ let bob = U256 :: from ( 3 ) ;
1062
1064
// Register Alice and Bob to the root network and alpha subnet.
1063
- register_ok_neuron ( alpha, alice, cold , 0 ) ;
1064
- register_ok_neuron ( alpha, bob, cold , 0 ) ;
1065
+ register_ok_neuron ( alpha, alice, cold_alice , 0 ) ;
1066
+ register_ok_neuron ( alpha, bob, cold_bob , 0 ) ;
1065
1067
assert_ok ! ( SubtensorModule :: root_register(
1066
- RuntimeOrigin :: signed( cold ) . clone( ) ,
1068
+ RuntimeOrigin :: signed( cold_alice ) . clone( ) ,
1067
1069
alice,
1068
1070
) ) ;
1069
1071
assert_ok ! ( SubtensorModule :: root_register(
1070
- RuntimeOrigin :: signed( cold ) . clone( ) ,
1072
+ RuntimeOrigin :: signed( cold_bob ) . clone( ) ,
1071
1073
bob,
1072
1074
) ) ;
1073
1075
// Add stake for Alice and Bob on root.
1074
1076
let alice_root_stake: u64 = 1_000_000_000 ;
1075
1077
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1076
1078
& alice,
1077
- & cold ,
1079
+ & cold_alice ,
1078
1080
root,
1079
1081
alice_root_stake,
1080
1082
) ;
1081
1083
let bob_root_stake: u64 = 1_000_000_000 ;
1082
1084
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1083
1085
& bob,
1084
- & cold ,
1086
+ & cold_bob ,
1085
1087
root,
1086
1088
alice_root_stake,
1087
1089
) ;
1088
1090
// Add stake for Alice and Bob on netuid.
1089
1091
let alice_alpha_stake: u64 = 1_000_000_000 ;
1090
1092
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1091
1093
& alice,
1092
- & cold ,
1094
+ & cold_alice ,
1093
1095
alpha,
1094
1096
alice_alpha_stake,
1095
1097
) ;
1096
1098
let bob_alpha_stake: u64 = 1_000_000_000 ;
1097
1099
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1098
1100
& bob,
1099
- & cold ,
1101
+ & cold_bob ,
1100
1102
alpha,
1101
1103
bob_alpha_stake,
1102
1104
) ;
@@ -1138,47 +1140,48 @@ fn test_get_root_children_drain_with_take() {
1138
1140
// Set TAO weight to 1.
1139
1141
SubtensorModule :: set_tao_weight ( u64:: MAX ) ; // Set TAO weight to 1.
1140
1142
// Create keys.
1141
- let cold = U256 :: from ( 0 ) ;
1142
- let alice = U256 :: from ( 1 ) ;
1143
- let bob = U256 :: from ( 2 ) ;
1143
+ let cold_alice = U256 :: from ( 0 ) ;
1144
+ let cold_bob = U256 :: from ( 1 ) ;
1145
+ let alice = U256 :: from ( 2 ) ;
1146
+ let bob = U256 :: from ( 3 ) ;
1144
1147
// Register Alice and Bob to the root network and alpha subnet.
1145
- register_ok_neuron ( alpha, alice, cold , 0 ) ;
1146
- register_ok_neuron ( alpha, bob, cold , 0 ) ;
1148
+ register_ok_neuron ( alpha, alice, cold_alice , 0 ) ;
1149
+ register_ok_neuron ( alpha, bob, cold_bob , 0 ) ;
1147
1150
assert_ok ! ( SubtensorModule :: root_register(
1148
- RuntimeOrigin :: signed( cold ) . clone( ) ,
1151
+ RuntimeOrigin :: signed( cold_alice ) . clone( ) ,
1149
1152
alice,
1150
1153
) ) ;
1151
1154
assert_ok ! ( SubtensorModule :: root_register(
1152
- RuntimeOrigin :: signed( cold ) . clone( ) ,
1155
+ RuntimeOrigin :: signed( cold_bob ) . clone( ) ,
1153
1156
bob,
1154
1157
) ) ;
1155
1158
// Add stake for Alice and Bob on root.
1156
1159
let alice_root_stake: u64 = 1_000_000_000 ;
1157
1160
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1158
1161
& alice,
1159
- & cold ,
1162
+ & cold_alice ,
1160
1163
root,
1161
1164
alice_root_stake,
1162
1165
) ;
1163
1166
let bob_root_stake: u64 = 1_000_000_000 ;
1164
1167
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1165
1168
& bob,
1166
- & cold ,
1169
+ & cold_bob ,
1167
1170
root,
1168
1171
alice_root_stake,
1169
1172
) ;
1170
1173
// Add stake for Alice and Bob on netuid.
1171
1174
let alice_alpha_stake: u64 = 1_000_000_000 ;
1172
1175
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1173
1176
& alice,
1174
- & cold ,
1177
+ & cold_alice ,
1175
1178
alpha,
1176
1179
alice_alpha_stake,
1177
1180
) ;
1178
1181
let bob_alpha_stake: u64 = 1_000_000_000 ;
1179
1182
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1180
1183
& bob,
1181
- & cold ,
1184
+ & cold_bob ,
1182
1185
alpha,
1183
1186
bob_alpha_stake,
1184
1187
) ;
@@ -1215,47 +1218,48 @@ fn test_get_root_children_drain_with_half_take() {
1215
1218
// Set TAO weight to 1.
1216
1219
SubtensorModule :: set_tao_weight ( u64:: MAX ) ; // Set TAO weight to 1.
1217
1220
// Create keys.
1218
- let cold = U256 :: from ( 0 ) ;
1219
- let alice = U256 :: from ( 1 ) ;
1220
- let bob = U256 :: from ( 2 ) ;
1221
+ let cold_alice = U256 :: from ( 0 ) ;
1222
+ let cold_bob = U256 :: from ( 1 ) ;
1223
+ let alice = U256 :: from ( 2 ) ;
1224
+ let bob = U256 :: from ( 3 ) ;
1221
1225
// Register Alice and Bob to the root network and alpha subnet.
1222
- register_ok_neuron ( alpha, alice, cold , 0 ) ;
1223
- register_ok_neuron ( alpha, bob, cold , 0 ) ;
1226
+ register_ok_neuron ( alpha, alice, cold_alice , 0 ) ;
1227
+ register_ok_neuron ( alpha, bob, cold_bob , 0 ) ;
1224
1228
assert_ok ! ( SubtensorModule :: root_register(
1225
- RuntimeOrigin :: signed( cold ) . clone( ) ,
1229
+ RuntimeOrigin :: signed( cold_alice ) . clone( ) ,
1226
1230
alice,
1227
1231
) ) ;
1228
1232
assert_ok ! ( SubtensorModule :: root_register(
1229
- RuntimeOrigin :: signed( cold ) . clone( ) ,
1233
+ RuntimeOrigin :: signed( cold_bob ) . clone( ) ,
1230
1234
bob,
1231
1235
) ) ;
1232
1236
// Add stake for Alice and Bob on root.
1233
1237
let alice_root_stake: u64 = 1_000_000_000 ;
1234
1238
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1235
1239
& alice,
1236
- & cold ,
1240
+ & cold_alice ,
1237
1241
root,
1238
1242
alice_root_stake,
1239
1243
) ;
1240
1244
let bob_root_stake: u64 = 1_000_000_000 ;
1241
1245
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1242
1246
& bob,
1243
- & cold ,
1247
+ & cold_bob ,
1244
1248
root,
1245
1249
alice_root_stake,
1246
1250
) ;
1247
1251
// Add stake for Alice and Bob on netuid.
1248
1252
let alice_alpha_stake: u64 = 1_000_000_000 ;
1249
1253
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1250
1254
& alice,
1251
- & cold ,
1255
+ & cold_alice ,
1252
1256
alpha,
1253
1257
alice_alpha_stake,
1254
1258
) ;
1255
1259
let bob_alpha_stake: u64 = 1_000_000_000 ;
1256
1260
SubtensorModule :: increase_stake_for_hotkey_and_coldkey_on_subnet (
1257
1261
& bob,
1258
- & cold ,
1262
+ & cold_bob ,
1259
1263
alpha,
1260
1264
bob_alpha_stake,
1261
1265
) ;
0 commit comments