Apply storage migration

Author: dio-will

pallets/crowdloans/src/lib.rs

@@ -1810,7 +1810,7 @@ pub mod pallet {
         ) -> DispatchResult {
             let ctoken = Self::ctoken_of((&lease_start, &lease_end))
                 .ok_or(Error::<T>::CTokenDoesNotExist)?;
-            let vault = Self::vaults((&crowdloan, &lease_start, &lease_end))
+            let mut vault = Self::vaults((&crowdloan, &lease_start, &lease_end))
                 .ok_or(Error::<T>::VaultDoesNotExist)?;
 
             ensure!(
@@ -1832,18 +1832,17 @@ pub mod pallet {
             let ctoken_balance = T::Assets::reducible_balance(ctoken, &who, false);
             ensure!(ctoken_balance >= amount, Error::<T>::InsufficientBalance);
 
-            // NOTE: skipping the vault contribution check
-            // vault.contributed = vault
-            //     .contributed
-            //     .checked_sub(amount)
-            //     .ok_or(ArithmeticError::Underflow)?;
+            vault.contributed = vault
+                .contributed
+                .checked_sub(amount)
+                .ok_or(ArithmeticError::Underflow)?;
 
             T::Assets::burn_from(ctoken, &who, amount)?;
             // SovereignAccount on relaychain must have
             // withdrawn the contribution
             T::Assets::mint_into(T::RelayCurrency::get(), &who, amount)?;
 
-            // Vaults::<T>::insert((&crowdloan, &lease_start, &lease_end), vault);
+            Vaults::<T>::insert((&crowdloan, &lease_start, &lease_end), vault);
 
             Self::deposit_event(Event::<T>::VaultRedeemed(
                 crowdloan,

pallets/crowdloans/src/migrations.rs

@@ -382,3 +382,86 @@ pub mod v3 {
         Ok(())
     }
 }
+
+pub mod v4 {
+    use super::*;
+    use frame_support::{log, traits::Get};
+    use primitives::ParaId;
+    use sp_std::{vec, vec::Vec};
+    use types::*;
+
+    pub fn pre_migrate<T: Config>() -> Result<Vec<u8>, &'static str> {
+        frame_support::ensure!(
+            StorageVersion::<T>::get() == Releases::V3_0_0,
+            "must be V3_0_0"
+        );
+        frame_support::ensure!(NextTrieIndex::<T>::get() == 31, "must be 31");
+        Ok(Vec::new())
+    }
+
+    pub fn migrate<T: Config>() -> frame_support::weights::Weight {
+        if StorageVersion::<T>::get() == Releases::V3_0_0 {
+            log::info!(
+                target: "crowdloans::migrate",
+                "migrating crowdloan storage"
+            );
+            // paraId, ctoken, contributed, cap, end_block, trie_index, lease_start, lease_end
+            let batch: Vec<(u32, u32, u128, u128, u32, u32, u32, u32)> = vec![
+                // 2040,8-15,3000000000000000,150000000000000000,10881401
+                (
+                    2040,
+                    200080015,
+                    3000000000000000,
+                    150_000_000_000_000_000,
+                    10881401,
+                    25,
+                    8,
+                    15,
+                ),
+            ];
+            let length = batch.len() as u64;
+            for (para_id, _, raised, _, _, _, lease_start, lease_end) in batch.into_iter() {
+                match Vaults::<T>::get((&ParaId::from(para_id), &lease_start, &lease_end)) {
+                    Some(vault) if vault.phase == VaultPhase::Expired => {
+                        Vaults::<T>::insert(
+                            (&ParaId::from(para_id), &lease_start, &lease_end),
+                            Vault {
+                                contributed: raised,
+                                ..vault
+                            },
+                        );
+                    }
+                    Some(_) => {
+                        log::error!("Vault for para_id {} is not in Expired phase", para_id);
+                    }
+                    None => {
+                        log::error!(
+                            "No vault found for para_id {} ({}, {})",
+                            para_id,
+                            lease_start,
+                            lease_end
+                        );
+                    }
+                }
+            }
+            log::info!(
+                target: "crowdloans::migrate",
+                "completed crowdloans storage migration"
+            );
+            <T as frame_system::Config>::DbWeight::get().writes(length * 3 + 1u64)
+        } else {
+            T::DbWeight::get().reads(1)
+        }
+    }
+
+    pub fn post_migrate<T: Config>() -> Result<(), &'static str> {
+        frame_support::ensure!(
+            StorageVersion::<T>::get() == Releases::V3_0_0,
+            "must be V3_0_0"
+        );
+        frame_support::ensure!(NextTrieIndex::<T>::get() == 31, "must be 31");
+        log::info!("👜 crowdloan migration passes POST migrate checks ✅",);
+
+        Ok(())
+    }
+}

runtime/parallel/src/lib.rs

@@ -2073,7 +2073,7 @@ pub type Executive = frame_executive::Executive<
     frame_system::ChainContext<Runtime>,
     Runtime,
     AllPalletsWithSystem,
-    CrowdloansMigrationV3,
+    CrowdloansMigrationV4,
 >;
 
 impl fp_self_contained::SelfContainedCall for RuntimeCall {
@@ -2134,6 +2134,23 @@ impl fp_self_contained::SelfContainedCall for RuntimeCall {
     }
 }
 
+pub struct CrowdloansMigrationV4;
+impl OnRuntimeUpgrade for CrowdloansMigrationV4 {
+    fn on_runtime_upgrade() -> frame_support::weights::Weight {
+        pallet_crowdloans::migrations::v4::migrate::<Runtime>()
+    }
+
+    #[cfg(feature = "try-runtime")]
+    fn pre_upgrade() -> Result<Vec<u8>, &'static str> {
+        pallet_crowdloans::migrations::v4::pre_migrate::<Runtime>()
+    }
+
+    #[cfg(feature = "try-runtime")]
+    fn post_upgrade(_: Vec<u8>) -> Result<(), &'static str> {
+        pallet_crowdloans::migrations::v4::post_migrate::<Runtime>()
+    }
+}
+
 impl_runtime_apis! {
     impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
         fn slot_duration() -> sp_consensus_aura::SlotDuration {