git.delta.rocks / unique-network / refs/commits / a4127fe2eb7d

--- a/node/cli/src/chain_spec.rs
+++ b/node/cli/src/chain_spec.rs
@@ -196,6 +196,7 @@
 					const_on_chain_schema: vec![],
 					variable_on_chain_schema: vec![],
 					limits: CollectionLimits::default(),
+					transfers_enabled: true,
 				},
 			)],
 			nft_item_id: vec![],

--- a/pallets/inflation/src/tests.rs
+++ b/pallets/inflation/src/tests.rs
@@ -31,6 +31,8 @@
 	type ExistentialDeposit = ExistentialDeposit;
 	type WeightInfo = ();
 	type MaxLocks = MaxLocks;
+	type MaxReserves = ();
+	type ReserveIdentifier = ();
 }
 
 frame_support::construct_runtime!(
@@ -89,7 +91,6 @@
 	type InflationBlockInterval = InflationBlockInterval;
 }
 
-// Build genesis storage according to the mock runtime.
 pub fn new_test_ext() -> sp_io::TestExternalities {
 	frame_system::GenesisConfig::default()
 		.build_storage::<Test>()
@@ -108,7 +109,9 @@
 		// BlockInflation should be set after 1st block and
 		// first inflation deposit should be equal to BlockInflation
 		Inflation::on_initialize(1);
-		assert!(Inflation::block_inflation() > 0);
+
+		// SBP M2 review: Verify expected block inflation for year 1
+		assert_eq!(Inflation::block_inflation(), 1901);
 		assert_eq!(
 			Balances::free_balance(1234) - initial_issuance,
 			Inflation::block_inflation()
@@ -155,11 +158,24 @@
 		Inflation::on_initialize(1);
 		let block_inflation_year_0 = Inflation::block_inflation();
 
+		// SBP M2 review: go through all the block inflations for year 1,
+		// total issuance will be updated accordingly
+		for block in (100..YEAR).step_by(100) {
+			Inflation::on_initialize(block);
+		}
+		assert_eq!(
+			initial_issuance + (1901 * (YEAR / 100)),
+			<Balances as Currency<_>>::total_issuance()
+		);
+
 		Inflation::on_initialize(YEAR);
 		let block_inflation_year_1 = Inflation::block_inflation();
+		// SBP M2 review: Verify expected block inflation for year 2
+		assert_eq!(block_inflation_year_1, 1952);
 
+		// SBP M2 review: this is actually not true
 		// Assert that year 1 inflation is less than year 0
-		assert!(block_inflation_year_0 > block_inflation_year_1);
+		// assert!(block_inflation_year_0 > block_inflation_year_1);
 	});
 }
 
@@ -177,6 +193,7 @@
 			Inflation::on_initialize(YEAR * year);
 			let block_inflation_year_after = Inflation::block_inflation();
 
+			// SBP M2 review: this is actually not true (not for the first few years)
 			// Assert that next year inflation is less than previous year inflation
 			assert!(block_inflation_year_before > block_inflation_year_after);
 		}

--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -174,6 +174,8 @@
 		BadCreateRefungibleCall,
 		/// Gas limit exceeded
 		OutOfGas,
+		/// Collection settings not allowing items transferring
+		TransferNotAllowed,
 	}
 }
 
@@ -526,6 +528,7 @@
 				variable_on_chain_schema: Vec::new(),
 				const_on_chain_schema: Vec::new(),
 				limits,
+				transfers_enabled: true,
 			};
 
 			// Add new collection to map
@@ -901,6 +904,32 @@
 			collection.submit_logs()
 		}
 
+		// TODO! transaction weight
+
+		/// Set transfers_enabled value for particular collection
+		///
+		/// # Permissions
+		///
+		/// * Collection Owner.
+		///
+		/// # Arguments
+		///
+		/// * collection_id: ID of the collection.
+		///
+		/// * value: New flag value.
+		#[weight = <T as Config>::WeightInfo::burn_item()]
+		#[transactional]
+		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {
+
+			let sender = ensure_signed(origin)?;
+			let mut target_collection = Self::get_collection(collection_id)?;
+
+			Self::check_owner_permissions(&target_collection, &sender)?;
+
+			target_collection.transfers_enabled = value;
+			target_collection.save()
+		}
+
 		/// Destroys a concrete instance of NFT.
 		///
 		/// # Permissions
@@ -1541,6 +1570,9 @@
 			Error::<T>::AccountTokenLimitExceeded
 		);
 
+		// preliminary transfer check
+		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);
+
 		Ok(())
 	}
 

--- a/pallets/nft/src/mock.rs
+++ b/pallets/nft/src/mock.rs
@@ -74,6 +74,8 @@
 	type ExistentialDeposit = ExistentialDeposit;
 	type WeightInfo = ();
 	type MaxLocks = MaxLocks;
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
 }
 
 parameter_types! {
@@ -99,41 +101,6 @@
 
 type Timestamp = pallet_timestamp::Pallet<Test>;
 type Randomness = pallet_randomness_collective_flip::Pallet<Test>;
-
-parameter_types! {
-	pub const TombstoneDeposit: u64 = 1;
-	pub const DepositPerContract: u64 = 1;
-	pub const DepositPerStorageByte: u64 = 1;
-	pub const DepositPerStorageItem: u64 = 1;
-	pub RentFraction: Perbill = Perbill::from_rational(1u32, 30 * 24 * 60 * 10);
-	pub const SurchargeReward: u64 = 1;
-	pub const SignedClaimHandicap: u32 = 2;
-	pub DeletionWeightLimit: u64 = u64::MAX;//Perbill::from_percent(10);
-	pub DeletionQueueDepth: u32 = 10;
-	pub Schedule: pallet_contracts::Schedule<Test> = Default::default();
-}
-
-impl pallet_contracts::Config for Test {
-	type Time = Timestamp;
-	type Randomness = Randomness;
-	type Currency = pallet_balances::Pallet<Test>;
-	type Event = ();
-	type RentPayment = ();
-	type SignedClaimHandicap = SignedClaimHandicap;
-	type TombstoneDeposit = TombstoneDeposit;
-	type DepositPerContract = DepositPerContract;
-	type DepositPerStorageByte = DepositPerStorageByte;
-	type DepositPerStorageItem = DepositPerStorageItem;
-	type RentFraction = RentFraction;
-	type SurchargeReward = SurchargeReward;
-	type DeletionWeightLimit = DeletionWeightLimit;
-	type DeletionQueueDepth = DeletionQueueDepth;
-	type ChainExtension = ();
-	type WeightPrice = ();
-	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
-	type Schedule = Schedule;
-	type CallStack = [pallet_contracts::Frame<Self>; 31];
-}
 
 parameter_types! {
 	pub const CollectionCreationPrice: u32 = 0;

--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -2351,3 +2351,62 @@
 		);
 	});
 }
+
+#[test]
+fn collection_transfer_flag_works() {
+	new_test_ext().execute_with(|| {
+		default_limits();
+
+		let origin1 = Origin::signed(1);
+
+		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
+		assert_ok!(TemplateModule::set_transfers_enabled_flag(origin1, 1, true));
+
+		let data = default_nft_data();
+		create_test_item(collection_id, &data.into());
+		assert_eq!(TemplateModule::balance_count(1, 1), 1);
+		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+
+		let origin1 = Origin::signed(1);
+
+		// default scenario
+		assert_ok!(TemplateModule::transfer(origin1, account(2), 1, 1, 1000));
+		assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(2));
+		assert_eq!(TemplateModule::balance_count(1, 1), 0);
+		assert_eq!(TemplateModule::balance_count(1, 2), 1);
+
+		assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
+	});
+}
+
+#[test]
+fn collection_transfer_flag_works_neg() {
+	new_test_ext().execute_with(|| {
+		default_limits();
+
+		let origin1 = Origin::signed(1);
+
+		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
+		assert_ok!(TemplateModule::set_transfers_enabled_flag(
+			origin1, 1, false
+		));
+
+		let data = default_nft_data();
+		create_test_item(collection_id, &data.into());
+		assert_eq!(TemplateModule::balance_count(1, 1), 1);
+		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+
+		let origin1 = Origin::signed(1);
+
+		// default scenario
+		assert_noop!(
+			TemplateModule::transfer(origin1, account(2), 1, 1, 1000),
+			Error::<Test>::TransferNotAllowed
+		);
+		assert_eq!(TemplateModule::nft_item_id(1, 1).unwrap().owner, account(1));
+		assert_eq!(TemplateModule::balance_count(1, 1), 1);
+		assert_eq!(TemplateModule::balance_count(1, 2), 0);
+
+		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+	});
+}

948		system::RawOrigin::Root.into()948		system::RawOrigin::Root.into()
949	}949	}
950
951	#[test]
952	fn basic_scheduling_works() {
953		new_test_ext().execute_with(|| {
954			let call = Call::Logger(logger::Call::log(42, 1000));
955			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(
956				&call
957			));
958			assert_ok!(Scheduler::do_schedule(
959				DispatchTime::At(4),
960				None,
961				127,
962				root(),
963				call
964			));
965			run_to_block(3);
966			assert!(logger::log().is_empty());
967			run_to_block(4);
968			assert_eq!(logger::log(), vec![(root(), 42u32)]);
969			run_to_block(100);
970			assert_eq!(logger::log(), vec![(root(), 42u32)]);
971		});
972	}
973
974	#[test]
975	fn schedule_after_works() {
976		new_test_ext().execute_with(|| {
977			run_to_block(2);
978			let call = Call::Logger(logger::Call::log(42, 1000));
979			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(
980				&call
981			));
982			// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6
983			assert_ok!(Scheduler::do_schedule(
984				DispatchTime::After(3),
985				None,
986				127,
987				root(),
988				call
989			));
990			run_to_block(5);
991			assert!(logger::log().is_empty());
992			run_to_block(6);
993			assert_eq!(logger::log(), vec![(root(), 42u32)]);
994			run_to_block(100);
995			assert_eq!(logger::log(), vec![(root(), 42u32)]);
996		});
997	}
998
999	#[test]
1000	fn schedule_after_zero_works() {
1001		new_test_ext().execute_with(|| {
1002			run_to_block(2);
1003			let call = Call::Logger(logger::Call::log(42, 1000));
1004			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(
1005				&call
1006			));
1007			assert_ok!(Scheduler::do_schedule(
1008				DispatchTime::After(0),
1009				None,
1010				127,
1011				root(),
1012				call
1013			));
1014			// Will trigger on the next block.
1015			run_to_block(3);
1016			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1017			run_to_block(100);
1018			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1019		});
1020	}
1021
1022	#[test]
1023	fn periodic_scheduling_works() {
1024		new_test_ext().execute_with(|| {
1025			// at #4, every 3 blocks, 3 times.
1026			assert_ok!(Scheduler::do_schedule(
1027				DispatchTime::At(4),
1028				Some((3, 3)),
1029				127,
1030				root(),
1031				Call::Logger(logger::Call::log(42, 1000))
1032			));
1033			run_to_block(3);
1034			assert!(logger::log().is_empty());
1035			run_to_block(4);
1036			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1037			run_to_block(6);
1038			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1039			run_to_block(7);
1040			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
1041			run_to_block(9);
1042			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
1043			run_to_block(10);
1044			assert_eq!(
1045				logger::log(),
1046				vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]
1047			);
1048			run_to_block(100);
1049			assert_eq!(
1050				logger::log(),
1051				vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]
1052			);
1053		});
1054	}
1055
1056	#[test]
1057	fn reschedule_works() {
1058		new_test_ext().execute_with(|| {
1059			let call = Call::Logger(logger::Call::log(42, 1000));
1060			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(
1061				&call
1062			));
1063			assert_eq!(
1064				Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), call).unwrap(),
1065				(4, 0)
1066			);
1067
1068			run_to_block(3);
1069			assert!(logger::log().is_empty());
1070
1071			assert_eq!(
1072				Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(),
1073				(6, 0)
1074			);
1075
1076			assert_noop!(
1077				Scheduler::do_reschedule((6, 0), DispatchTime::At(6)),
1078				Error::<Test>::RescheduleNoChange
1079			);
1080
1081			run_to_block(4);
1082			assert!(logger::log().is_empty());
1083
1084			run_to_block(6);
1085			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1086
1087			run_to_block(100);
1088			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1089		});
1090	}
1091
1092	#[test]
1093	fn reschedule_named_works() {
1094		new_test_ext().execute_with(|| {
1095			let call = Call::Logger(logger::Call::log(42, 1000));
1096			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(
1097				&call
1098			));
1099			assert_eq!(
1100				Scheduler::do_schedule_named(
1101					1u32.encode(),
1102					DispatchTime::At(4),
1103					None,
1104					127,
1105					root(),
1106					call
1107				)
1108				.unwrap(),
1109				(4, 0)
1110			);
1111
1112			run_to_block(3);
1113			assert!(logger::log().is_empty());
1114
1115			assert_eq!(
1116				Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(),
1117				(6, 0)
1118			);
1119
1120			assert_noop!(
1121				Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)),
1122				Error::<Test>::RescheduleNoChange
1123			);
1124
1125			run_to_block(4);
1126			assert!(logger::log().is_empty());
1127
1128			run_to_block(6);
1129			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1130
1131			run_to_block(100);
1132			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1133		});
1134	}
1135
1136	#[test]
1137	fn reschedule_named_perodic_works() {
1138		new_test_ext().execute_with(|| {
1139			let call = Call::Logger(logger::Call::log(42, 1000));
1140			assert!(!<Test as frame_system::Config>::BaseCallFilter::filter(
1141				&call
1142			));
1143			assert_eq!(
1144				Scheduler::do_schedule_named(
1145					1u32.encode(),
1146					DispatchTime::At(4),
1147					Some((3, 3)),
1148					127,
1149					root(),
1150					call
1151				)
1152				.unwrap(),
1153				(4, 0)
1154			);
1155
1156			run_to_block(3);
1157			assert!(logger::log().is_empty());
1158
1159			assert_eq!(
1160				Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(5)).unwrap(),
1161				(5, 0)
1162			);
1163			assert_eq!(
1164				Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(6)).unwrap(),
1165				(6, 0)
1166			);
1167
1168			run_to_block(5);
1169			assert!(logger::log().is_empty());
1170
1171			run_to_block(6);
1172			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1173
1174			assert_eq!(
1175				Scheduler::do_reschedule_named(1u32.encode(), DispatchTime::At(10)).unwrap(),
1176				(10, 0)
1177			);
1178
1179			run_to_block(9);
1180			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1181
1182			run_to_block(10);
1183			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
1184
1185			run_to_block(13);
1186			assert_eq!(
1187				logger::log(),
1188				vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]
1189			);
1190
1191			run_to_block(100);
1192			assert_eq!(
1193				logger::log(),
1194				vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]
1195			);
1196		});
1197	}
1198
1199	#[test]
1200	fn cancel_named_scheduling_works_with_normal_cancel() {
1201		new_test_ext().execute_with(|| {
1202			// at #4.
1203			Scheduler::do_schedule_named(
1204				1u32.encode(),
1205				DispatchTime::At(4),
1206				None,
1207				127,
1208				root(),
1209				Call::Logger(logger::Call::log(69, 1000)),
1210			)
1211			.unwrap();
1212			let i = Scheduler::do_schedule(
1213				DispatchTime::At(4),
1214				None,
1215				127,
1216				root(),
1217				Call::Logger(logger::Call::log(42, 1000)),
1218			)
1219			.unwrap();
1220			run_to_block(3);
1221			assert!(logger::log().is_empty());
1222			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));
1223			assert_ok!(Scheduler::do_cancel(None, i));
1224			run_to_block(100);
1225			assert!(logger::log().is_empty());
1226		});
1227	}
1228
1229	#[test]
1230	fn cancel_named_periodic_scheduling_works() {
1231		new_test_ext().execute_with(|| {
1232			// at #4, every 3 blocks, 3 times.
1233			Scheduler::do_schedule_named(
1234				1u32.encode(),
1235				DispatchTime::At(4),
1236				Some((3, 3)),
1237				127,
1238				root(),
1239				Call::Logger(logger::Call::log(42, 1000)),
1240			)
1241			.unwrap();
1242			// same id results in error.
1243			assert!(Scheduler::do_schedule_named(
1244				1u32.encode(),
1245				DispatchTime::At(4),
1246				None,
1247				127,
1248				root(),
1249				Call::Logger(logger::Call::log(69, 1000))
1250			)
1251			.is_err());
1252			// different id is ok.
1253			Scheduler::do_schedule_named(
1254				2u32.encode(),
1255				DispatchTime::At(8),
1256				None,
1257				127,
1258				root(),
1259				Call::Logger(logger::Call::log(69, 1000)),
1260			)
1261			.unwrap();
1262			run_to_block(3);
1263			assert!(logger::log().is_empty());
1264			run_to_block(4);
1265			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1266			run_to_block(6);
1267			assert_ok!(Scheduler::do_cancel_named(None, 1u32.encode()));
1268			run_to_block(100);
1269			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
1270		});
1271	}
1272
1273	#[test]
1274	fn scheduler_respects_weight_limits() {
1275		new_test_ext().execute_with(|| {
1276			assert_ok!(Scheduler::do_schedule(
1277				DispatchTime::At(4),
1278				None,
1279				127,
1280				root(),
1281				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))
1282			));
1283			assert_ok!(Scheduler::do_schedule(
1284				DispatchTime::At(4),
1285				None,
1286				127,
1287				root(),
1288				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
1289			));
1290			// 69 and 42 do not fit together
1291			run_to_block(4);
1292			assert_eq!(logger::log(), vec![(root(), 42u32)]);
1293			run_to_block(5);
1294			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
1295		});
1296	}
1297
1298	#[test]
1299	fn scheduler_respects_hard_deadlines_more() {
1300		new_test_ext().execute_with(|| {
1301			assert_ok!(Scheduler::do_schedule(
1302				DispatchTime::At(4),
1303				None,
1304				0,
1305				root(),
1306				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))
1307			));
1308			assert_ok!(Scheduler::do_schedule(
1309				DispatchTime::At(4),
1310				None,
1311				0,
1312				root(),
1313				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
1314			));
1315			// With base weights, 69 and 42 should not fit together, but do because of hard deadlines
1316			run_to_block(4);
1317			assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
1318		});
1319	}
1320
1321	#[test]
1322	fn scheduler_respects_priority_ordering() {
1323		new_test_ext().execute_with(|| {
1324			assert_ok!(Scheduler::do_schedule(
1325				DispatchTime::At(4),
1326				None,
1327				1,
1328				root(),
1329				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 2))
1330			));
1331			assert_ok!(Scheduler::do_schedule(
1332				DispatchTime::At(4),
1333				None,
1334				0,
1335				root(),
1336				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
1337			));
1338			run_to_block(4);
1339			assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);
1340		});
1341	}
1342
1343	#[test]
1344	fn scheduler_respects_priority_ordering_with_soft_deadlines() {
1345		new_test_ext().execute_with(|| {
1346			assert_ok!(Scheduler::do_schedule(
1347				DispatchTime::At(4),
1348				None,
1349				255,
1350				root(),
1351				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))
1352			));
1353			assert_ok!(Scheduler::do_schedule(
1354				DispatchTime::At(4),
1355				None,
1356				127,
1357				root(),
1358				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
1359			));
1360			assert_ok!(Scheduler::do_schedule(
1361				DispatchTime::At(4),
1362				None,
1363				126,
1364				root(),
1365				Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))
1366			));
1367
1368			// 2600 does not fit with 69 or 42, but has higher priority, so will go through
1369			run_to_block(4);
1370			assert_eq!(logger::log(), vec![(root(), 2600u32)]);
1371			// 69 and 42 fit together
1372			run_to_block(5);
1373			assert_eq!(
1374				logger::log(),
1375				vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]
1376			);
1377		});
1378	}
1379
1380	#[test]
1381	fn on_initialize_weight_is_correct() {
1382		new_test_ext().execute_with(|| {
1383			let base_weight: Weight =
1384				<Test as frame_system::Config>::DbWeight::get().reads_writes(1, 2);
1385			let base_multiplier = 0;
1386			let named_multiplier = <Test as frame_system::Config>::DbWeight::get().writes(1);
1387			let periodic_multiplier =
1388				<Test as frame_system::Config>::DbWeight::get().reads_writes(1, 1);
1389
1390			// Named
1391			assert_ok!(Scheduler::do_schedule_named(
1392				1u32.encode(),
1393				DispatchTime::At(1),
1394				None,
1395				255,
1396				root(),
1397				Call::Logger(logger::Call::log(3, MaximumSchedulerWeight::get() / 3))
1398			));
1399			// Anon Periodic
1400			assert_ok!(Scheduler::do_schedule(
1401				DispatchTime::At(1),
1402				Some((1000, 3)),
1403				128,
1404				root(),
1405				Call::Logger(logger::Call::log(42, MaximumSchedulerWeight::get() / 3))
1406			));
1407			// Anon
1408			assert_ok!(Scheduler::do_schedule(
1409				DispatchTime::At(1),
1410				None,
1411				127,
1412				root(),
1413				Call::Logger(logger::Call::log(69, MaximumSchedulerWeight::get() / 2))
1414			));
1415			// Named Periodic
1416			assert_ok!(Scheduler::do_schedule_named(
1417				2u32.encode(),
1418				DispatchTime::At(1),
1419				Some((1000, 3)),
1420				126,
1421				root(),
1422				Call::Logger(logger::Call::log(2600, MaximumSchedulerWeight::get() / 2))
1423			));
1424
1425			// Will include the named periodic only
1426			let actual_weight = Scheduler::on_initialize(1);
1427			let call_weight = MaximumSchedulerWeight::get() / 2;
1428			assert_eq!(
1429				actual_weight,
1430				call_weight
1431					+ base_weight + base_multiplier
1432					+ named_multiplier + periodic_multiplier
1433			);
1434			assert_eq!(logger::log(), vec![(root(), 2600u32)]);
1435
1436			// Will include anon and anon periodic
1437			let actual_weight = Scheduler::on_initialize(2);
1438			let call_weight = MaximumSchedulerWeight::get() / 2 + MaximumSchedulerWeight::get() / 3;
1439			assert_eq!(
1440				actual_weight,
1441				call_weight + base_weight + base_multiplier * 2 + periodic_multiplier
1442			);
1443			assert_eq!(
1444				logger::log(),
1445				vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]
1446			);
1447
1448			// Will include named only
1449			let actual_weight = Scheduler::on_initialize(3);
1450			let call_weight = MaximumSchedulerWeight::get() / 3;
1451			assert_eq!(
1452				actual_weight,
1453				call_weight + base_weight + base_multiplier + named_multiplier
1454			);
1455			assert_eq!(
1456				logger::log(),
1457				vec![
1458					(root(), 2600u32),
1459					(root(), 69u32),
1460					(root(), 42u32),
1461					(root(), 3u32)
1462				]
1463			);
1464
1465			// Will contain none
1466			let actual_weight = Scheduler::on_initialize(4);
1467			assert_eq!(actual_weight, 0);
1468		});
1469	}
1470
1471	#[test]
1472	fn root_calls_works() {
1473		new_test_ext().execute_with(|| {
1474			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));
1475			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));
1476			assert_ok!(Scheduler::schedule_named(
1477				Origin::root(),
1478				1u32.encode(),
1479				4,
1480				None,
1481				127,
1482				call
1483			));
1484			assert_ok!(Scheduler::schedule(Origin::root(), 4, None, 127, call2));
1485			run_to_block(3);
1486			// Scheduled calls are in the agenda.
1487			assert_eq!(Agenda::<Test>::get(4).len(), 2);
1488			assert!(logger::log().is_empty());
1489			assert_ok!(Scheduler::cancel_named(Origin::root(), 1u32.encode()));
1490			assert_ok!(Scheduler::cancel(Origin::root(), 4, 1));
1491			// Scheduled calls are made NONE, so should not effect state
1492			run_to_block(100);
1493			assert!(logger::log().is_empty());
1494		});
1495	}
1496
1497	#[test]
1498	fn fails_to_schedule_task_in_the_past() {
1499		new_test_ext().execute_with(|| {
1500			run_to_block(3);
1501
1502			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));
1503			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));
1504
1505			assert_err!(
1506				Scheduler::schedule_named(Origin::root(), 1u32.encode(), 2, None, 127, call),
1507				Error::<Test>::TargetBlockNumberInPast,
1508			);
1509
1510			assert_err!(
1511				Scheduler::schedule(Origin::root(), 2, None, 127, call2.clone()),
1512				Error::<Test>::TargetBlockNumberInPast,
1513			);
1514
1515			assert_err!(
1516				Scheduler::schedule(Origin::root(), 3, None, 127, call2),
1517				Error::<Test>::TargetBlockNumberInPast,
1518			);
1519		});
1520	}
1521
1522	#[test]
1523	fn should_use_orign() {
1524		new_test_ext().execute_with(|| {
1525			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));
1526			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));
1527			assert_ok!(Scheduler::schedule_named(
1528				system::RawOrigin::Signed(1).into(),
1529				1u32.encode(),
1530				4,
1531				None,
1532				127,
1533				call
1534			));
1535			assert_ok!(Scheduler::schedule(
1536				system::RawOrigin::Signed(1).into(),
1537				4,
1538				None,
1539				127,
1540				call2
1541			));
1542			run_to_block(3);
1543			// Scheduled calls are in the agenda.
1544			assert_eq!(Agenda::<Test>::get(4).len(), 2);
1545			assert!(logger::log().is_empty());
1546			assert_ok!(Scheduler::cancel_named(
1547				system::RawOrigin::Signed(1).into(),
1548				1u32.encode()
1549			));
1550			assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));
1551			// Scheduled calls are made NONE, so should not effect state
1552			run_to_block(100);
1553			assert!(logger::log().is_empty());
1554		});
1555	}
1556
1557	#[test]
1558	fn should_check_orign() {
1559		new_test_ext().execute_with(|| {
1560			let call = Box::new(Call::Logger(logger::Call::log(69, 1000)));
1561			let call2 = Box::new(Call::Logger(logger::Call::log(42, 1000)));
1562			assert_noop!(
1563				Scheduler::schedule_named(
1564					system::RawOrigin::Signed(2).into(),
1565					1u32.encode(),
1566					4,
1567					None,
1568					127,
1569					call
1570				),
1571				BadOrigin
1572			);
1573			assert_noop!(
1574				Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2),
1575				BadOrigin
1576			);
1577		});
1578	}
1579
1580	#[test]
1581	fn should_check_orign_for_cancel() {
1582		new_test_ext().execute_with(|| {
1583			let call = Box::new(Call::Logger(logger::Call::log_without_filter(69, 1000)));
1584			let call2 = Box::new(Call::Logger(logger::Call::log_without_filter(42, 1000)));
1585			assert_ok!(Scheduler::schedule_named(
1586				system::RawOrigin::Signed(1).into(),
1587				1u32.encode(),
1588				4,
1589				None,
1590				127,
1591				call
1592			));
1593			assert_ok!(Scheduler::schedule(
1594				system::RawOrigin::Signed(1).into(),
1595				4,
1596				None,
1597				127,
1598				call2
1599			));
1600			run_to_block(3);
1601			// Scheduled calls are in the agenda.
1602			assert_eq!(Agenda::<Test>::get(4).len(), 2);
1603			assert!(logger::log().is_empty());
1604			assert_noop!(
1605				Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), 1u32.encode()),
1606				BadOrigin
1607			);
1608			assert_noop!(
1609				Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1),
1610				BadOrigin
1611			);
1612			assert_noop!(
1613				Scheduler::cancel_named(system::RawOrigin::Root.into(), 1u32.encode()),
1614				BadOrigin
1615			);
1616			assert_noop!(
1617				Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1),
1618				BadOrigin
1619			);
1620			run_to_block(5);
1621			assert_eq!(
1622				logger::log(),
1623				vec![
1624					(system::RawOrigin::Signed(1).into(), 69u32),
1625					(system::RawOrigin::Signed(1).into(), 42u32)
1626				]
1627			);
1628		});
1629	}
1630
1631	#[test]
1632	fn migration_to_v2_works() {
1633		new_test_ext().execute_with(|| {
1634			for i in 0..3u64 {
1635				let k = i.twox_64_concat();
1636				let old = vec![
1637					Some(ScheduledV1 {
1638						maybe_id: None,
1639						priority: i as u8 + 10,
1640						call: Call::Logger(logger::Call::log(96, 100)),
1641						maybe_periodic: None,
1642					}),
1643					None,
1644					Some(ScheduledV1 {
1645						maybe_id: Some(b"test".to_vec()),
1646						priority: 123,
1647						call: Call::Logger(logger::Call::log(69, 1000)),
1648						maybe_periodic: Some((456u64, 10)),
1649					}),
1650				];
1651				frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
1652			}
1653
1654			assert_eq!(StorageVersion::get(), Releases::V1);
1655
1656			assert!(Scheduler::migrate_v1_to_t2());
1657
1658			assert_eq_uvec!(
1659				Agenda::<Test>::iter().collect::<Vec<_>>(),
1660				vec![
1661					(
1662						0,
1663						vec![
1664							Some(ScheduledV2 {
1665								maybe_id: None,
1666								priority: 10,
1667								call: Call::Logger(logger::Call::log(96, 100)),
1668								maybe_periodic: None,
1669								origin: root(),
1670								_phantom: PhantomData::<u64>::default(),
1671							}),
1672							None,
1673							Some(ScheduledV2 {
1674								maybe_id: Some(b"test".to_vec()),
1675								priority: 123,
1676								call: Call::Logger(logger::Call::log(69, 1000)),
1677								maybe_periodic: Some((456u64, 10)),
1678								origin: root(),
1679								_phantom: PhantomData::<u64>::default(),
1680							}),
1681						]
1682					),
1683					(
1684						1,
1685						vec![
1686							Some(ScheduledV2 {
1687								maybe_id: None,
1688								priority: 11,
1689								call: Call::Logger(logger::Call::log(96, 100)),
1690								maybe_periodic: None,
1691								origin: root(),
1692								_phantom: PhantomData::<u64>::default(),
1693							}),
1694							None,
1695							Some(ScheduledV2 {
1696								maybe_id: Some(b"test".to_vec()),
1697								priority: 123,
1698								call: Call::Logger(logger::Call::log(69, 1000)),
1699								maybe_periodic: Some((456u64, 10)),
1700								origin: root(),
1701								_phantom: PhantomData::<u64>::default(),
1702							}),
1703						]
1704					),
1705					(
1706						2,
1707						vec![
1708							Some(ScheduledV2 {
1709								maybe_id: None,
1710								priority: 12,
1711								call: Call::Logger(logger::Call::log(96, 100)),
1712								maybe_periodic: None,
1713								origin: root(),
1714								_phantom: PhantomData::<u64>::default(),
1715							}),
1716							None,
1717							Some(ScheduledV2 {
1718								maybe_id: Some(b"test".to_vec()),
1719								priority: 123,
1720								call: Call::Logger(logger::Call::log(69, 1000)),
1721								maybe_periodic: Some((456u64, 10)),
1722								origin: root(),
1723								_phantom: PhantomData::<u64>::default(),
1724							}),
1725						]
1726					)
1727				]
1728			);
1729
1730			assert_eq!(StorageVersion::get(), Releases::V2);
1731		});
1732	}
1733
1734	#[test]
1735	fn test_migrate_origin() {
1736		new_test_ext().execute_with(|| {
1737			for i in 0..3u64 {
1738				let k = i.twox_64_concat();
1739				let old: Vec<Option<Scheduled<_, _, u32, u64>>> = vec![
1740					Some(Scheduled {
1741						maybe_id: None,
1742						priority: i as u8 + 10,
1743						call: Call::Logger(logger::Call::log(96, 100)),
1744						origin: 3u32,
1745						maybe_periodic: None,
1746						_phantom: Default::default(),
1747					}),
1748					None,
1749					Some(Scheduled {
1750						maybe_id: Some(b"test".to_vec()),
1751						priority: 123,
1752						origin: 2u32,
1753						call: Call::Logger(logger::Call::log(69, 1000)),
1754						maybe_periodic: Some((456u64, 10)),
1755						_phantom: Default::default(),
1756					}),
1757				];
1758				frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
1759			}
1760
1761			impl From<u32> for OriginCaller {
1762				fn from(value: u32) -> Self {
1763					match value {
1764						3 => system::RawOrigin::Root.into(),
1765						2 => system::RawOrigin::None.into(),
1766						_ => unimplemented!(),
1767					}
1768				}
1769			}
1770
1771			Scheduler::migrate_origin::<u32>();
1772
1773			assert_eq_uvec!(
1774				Agenda::<Test>::iter().collect::<Vec<_>>(),
1775				vec![
1776					(
1777						0,
1778						vec![
1779							Some(ScheduledV2::<_, _, OriginCaller, u64> {
1780								maybe_id: None,
1781								priority: 10,
1782								call: Call::Logger(logger::Call::log(96, 100)),
1783								maybe_periodic: None,
1784								origin: system::RawOrigin::Root.into(),
1785								_phantom: PhantomData::<u64>::default(),
1786							}),
1787							None,
1788							Some(ScheduledV2 {
1789								maybe_id: Some(b"test".to_vec()),
1790								priority: 123,
1791								call: Call::Logger(logger::Call::log(69, 1000)),
1792								maybe_periodic: Some((456u64, 10)),
1793								origin: system::RawOrigin::None.into(),
1794								_phantom: PhantomData::<u64>::default(),
1795							}),
1796						]
1797					),
1798					(
1799						1,
1800						vec![
1801							Some(ScheduledV2 {
1802								maybe_id: None,
1803								priority: 11,
1804								call: Call::Logger(logger::Call::log(96, 100)),
1805								maybe_periodic: None,
1806								origin: system::RawOrigin::Root.into(),
1807								_phantom: PhantomData::<u64>::default(),
1808							}),
1809							None,
1810							Some(ScheduledV2 {
1811								maybe_id: Some(b"test".to_vec()),
1812								priority: 123,
1813								call: Call::Logger(logger::Call::log(69, 1000)),
1814								maybe_periodic: Some((456u64, 10)),
1815								origin: system::RawOrigin::None.into(),
1816								_phantom: PhantomData::<u64>::default(),
1817							}),
1818						]
1819					),
1820					(
1821						2,
1822						vec![
1823							Some(ScheduledV2 {
1824								maybe_id: None,
1825								priority: 12,
1826								call: Call::Logger(logger::Call::log(96, 100)),
1827								maybe_periodic: None,
1828								origin: system::RawOrigin::Root.into(),
1829								_phantom: PhantomData::<u64>::default(),
1830							}),
1831							None,
1832							Some(ScheduledV2 {
1833								maybe_id: Some(b"test".to_vec()),
1834								priority: 123,
1835								call: Call::Logger(logger::Call::log(69, 1000)),
1836								maybe_periodic: Some((456u64, 10)),
1837								origin: system::RawOrigin::None.into(),
1838								_phantom: PhantomData::<u64>::default(),
1839							}),
1840						]
1841					)
1842				]
1843			);
1844		});
1845	}
1846}950}
1847951