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,4 @@
+//! Migrations
+
+mod storage_migrations;
+mod vesting_info;

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

@@ -200,11 +200,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,162 @@
+// storage_migrations.rs
+
+use super::*;
+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, BoundedVec};
+
+pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(7); // Update version
+
+pub mod v7 {
+	use super::*;
+
+	const LOG: &str = "funding::migration::v7";
+	pub const MAX_PARTICIPATIONS_PER_USER: u32 = 16 + 16 + 16;
+
+	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,
+				BoundedVec<Migration, ConstU32<MAX_PARTICIPATIONS_PER_USER>>,
+			)|
+			 -> Option<(
+				MigrationStatus,
+				BoundedVec<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 = BoundedVec::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();
+
+			ensure!(
+				pre_migration_count == post_migration_count,
+				"UserMigrations count mismatch: pre={} post={}",
+				pre_migration_count,
+				post_migration_count
+			);
+			ensure!(
+				pre_vesting_count == post_vesting_count,
+				"Vesting entries count mismatch: pre={} post={}",
+				pre_vesting_count,
+				post_vesting_count
+			);
+
+			// 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)
+				})?;
+				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)
+						})?;
+
+				ensure!(
+					post_vesting_time == pre_vesting_time / 2,
+					"Vesting time not halved: project={} account={:?} pre={} post={}",
+					project_id,
+					account,
+					pre_vesting_time,
+					post_vesting_time
+				);
+			}
+
+			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,
+	>;
+}