Migrated pallet funding for block number provider

Author: dastansam

pallets/funding/src/lib.rs

@@ -95,7 +95,7 @@ pub use types::*;
 use xcm::v5::prelude::*;
 
 pub mod functions;
-pub mod storage_migrations;
+pub mod migrations;
 pub mod traits;
 pub mod types;
 pub mod weights;
@@ -166,7 +166,7 @@ pub mod pallet {
 	}
 
 	#[pallet::pallet]
-	#[pallet::storage_version(storage_migrations::STORAGE_VERSION)]
+	#[pallet::storage_version(migrations::STORAGE_VERSION)]
 	pub struct Pallet<T>(_);
 
 	#[pallet::config]

pallets/funding/src/migrations/mod.rs

@@ -0,0 +1,9 @@
+//! Migrations
+
+use frame_support::traits::StorageVersion;
+
+mod storage_migrations;
+mod vesting_info;
+
+/// Current storage version
+pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(7);

pallets/funding/src/storage_migrations.rs pallets/funding/src/migrations/storage_migrations.rs

@@ -15,10 +15,6 @@ use alloc::vec::Vec;
 use polimec_common::migration_types::{MigrationInfo, ParticipationType};
 use xcm::v5::Location;
 
-/// The current storage version
-pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(6);
-pub const LOG: &str = "runtime::funding::migration";
-
 pub mod v5_storage_items {
 
 	#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
@@ -200,11 +196,11 @@ pub mod v5_storage_items {
 }
 
 pub mod v6 {
-	use super::*;
-	use crate::{
-		storage_migrations::v5_storage_items::{OldMigration, OldProjectStatus, MAX_PARTICIPATIONS_PER_USER},
-		EvaluationRoundInfo, ProjectDetailsOf, ProjectStatus, TicketSize,
+	use super::{
+		v5_storage_items::{OldMigration, OldProjectStatus, MAX_PARTICIPATIONS_PER_USER},
+		*,
 	};
+	use crate::{EvaluationRoundInfo, ProjectDetailsOf, ProjectStatus, TicketSize};
 	use frame_system::pallet_prelude::BlockNumberFor;
 	use polimec_common::{
 		credentials::Did,

pallets/funding/src/migrations/vesting_info.rs

@@ -0,0 +1,146 @@
+// storage_migrations.rs
+
+use crate::Config;
+use alloc::vec::Vec;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{StorageVersion, UncheckedOnRuntimeUpgrade},
+	weights::Weight,
+};
+use polimec_common::migration_types::{Migration, MigrationInfo, MigrationStatus};
+use sp_runtime::{traits::ConstU32, WeakBoundedVec};
+
+pub mod v7 {
+	use crate::{AccountIdOf, ProjectId, UserMigrations};
+
+	use super::*;
+
+	const LOG: &str = "funding::migration::v7";
+	pub const MAX_PARTICIPATIONS_PER_USER: u32 = 10_000;
+
+	pub struct UncheckedMigrationToV7<T: Config>(PhantomData<T>);
+	impl<T: Config> UncheckedOnRuntimeUpgrade for UncheckedMigrationToV7<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let mut items = 0u64;
+			log::info!(target: LOG, "Starting vesting time migration to V7");
+
+			let translate_migration = |project_user: (ProjectId, AccountIdOf<T>),
+			                           (status, migrations): (
+				MigrationStatus,
+				WeakBoundedVec<Migration, ConstU32<MAX_PARTICIPATIONS_PER_USER>>,
+			)|
+			 -> Option<(
+				MigrationStatus,
+				WeakBoundedVec<Migration, ConstU32<MAX_PARTICIPATIONS_PER_USER>>,
+			)> {
+				let mut migrated = Vec::new();
+
+				for mut migration in migrations.into_iter() {
+					items = items.saturating_add(1);
+					// Halve the number of blocks while maintaining same real-time duration
+					// Assumes block time increases from 6s to 12s
+					if let MigrationInfo { vesting_time, contribution_token_amount } = migration.info {
+						migration.info =
+							MigrationInfo { vesting_time: vesting_time.saturating_div(2), contribution_token_amount };
+					}
+					migrated.push(migration);
+				}
+
+				let bounded = WeakBoundedVec::try_from(migrated)
+					.unwrap_or_else(|_| panic!("MaxParticipationsPerUser exceeded during migration"));
+
+				Some((status, bounded))
+			};
+
+			UserMigrations::<T>::translate(translate_migration);
+
+			log::info!(target: LOG, "Migrated {} vesting entries", items);
+			T::DbWeight::get().reads_writes(items, items)
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, DispatchError> {
+			let migration_count = UserMigrations::<T>::iter().count() as u32;
+			let vesting_count: u32 = UserMigrations::<T>::iter_values()
+				.map(|(_, migrations)| {
+					migrations.into_iter().filter(|m| matches!(m.info, MigrationInfo { .. })).count() as u32
+				})
+				.sum();
+			log::info!(target: LOG, "Pre-upgrade: {} UserMigrations entries, {} vesting entries", migration_count, vesting_count);
+
+			// Encode counts and sample pre-migration vesting times for validation
+			let mut state = Vec::new();
+			state.extend(migration_count.to_le_bytes());
+			state.extend(vesting_count.to_le_bytes());
+			for ((project_id, account), (_, migrations)) in UserMigrations::<T>::iter() {
+				for migration in migrations {
+					if let MigrationInfo::Vesting { vesting_time, .. } = migration.info {
+						state.extend(project_id.to_le_bytes());
+						state.extend(T::AccountId32Conversion::convert(account.clone()));
+						state.extend(vesting_time.to_le_bytes());
+						break; // Sample one per entry for simplicity
+					}
+				}
+			}
+			Ok(state)
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(pre_state: Vec<u8>) -> Result<(), DispatchError> {
+			let pre_migration_count = u32::from_le_bytes(pre_state[0..4].try_into().unwrap());
+			let pre_vesting_count = u32::from_le_bytes(pre_state[4..8].try_into().unwrap());
+			let post_migration_count = UserMigrations::<T>::iter().count() as u32;
+			let post_vesting_count: u32 = UserMigrations::<T>::iter_values()
+				.map(|(_, migrations)| {
+					migrations.into_iter().filter(|m| matches!(m.info, MigrationInfo { .. })).count() as u32
+				})
+				.sum();
+
+			assert_eq!(pre_migration_count, post_migration_count, "UserMigrations count mismatch",);
+			assert_eq!(pre_vesting_count, post_vesting_count, "Vesting entries count mismatch",);
+
+			// Validate vesting times are halved
+			let mut offset = 8;
+			while offset + 44 < pre_state.len() {
+				// 4 (project_id) + 32 (account) + 8 (vesting_time)
+				let project_id = ProjectId::from_le_bytes(pre_state[offset..offset + 4].try_into().unwrap());
+				let account_bytes: [u8; 32] = pre_state[offset + 4..offset + 36].try_into().unwrap();
+				let account = T::AccountId32Conversion::convert_back(account_bytes);
+				let pre_vesting_time = u64::from_le_bytes(pre_state[offset + 36..offset + 44].try_into().unwrap());
+				offset += 44;
+
+				let (_, migrations) = UserMigrations::<T>::get((project_id, account.clone()))
+					.ok_or_else(|| {
+						format!("Migration entry for project {} account {:?} not found", project_id, account)
+					})
+					.unwrap();
+				let post_vesting_time = migrations
+					.into_iter()
+					.find_map(
+						|m| {
+							if let MigrationInfo { vesting_time, .. } = m.info {
+								Some(vesting_time)
+							} else {
+								None
+							}
+						},
+					)
+					.ok_or_else(|| format!("Vesting info not found for project {} account {:?}", project_id, account))
+					.unwrap();
+
+				assert_eq!(post_vesting_time, pre_vesting_time / 2, "Vesting time not halved",);
+			}
+
+			log::info!(target: LOG, "Post-upgrade checks passed: {} migrations, {} vesting entries", post_migration_count, post_vesting_count);
+			Ok(())
+		}
+	}
+
+	pub type MigrationToV7<T> = frame_support::migrations::VersionedMigration<
+		6,
+		7,
+		UncheckedMigrationToV7<T>,
+		crate::Pallet<T>,
+		<T as frame_system::Config>::DbWeight,
+	>;
+}