initialise total issuance with a migration

pallets/subtensor/src/events.rs

@@ -132,21 +132,6 @@ mod events {
         MinDelegateTakeSet(u16),
         /// the target stakes per interval is set by sudo/admin transaction
         TargetStakesPerIntervalSet(u64),
-        /// Total issuance was rejigged
-        TotalIssuanceRejigged {
-            /// If Some a signed account, or root
-            who: Option<T::AccountId>,
-            /// The previous pallet total issuance
-            prev_total_issuance: u64,
-            /// The new pallet total issuance
-            new_total_issuance: u64,
-            /// The total amount of tokens staked
-            total_stake: u64,
-            /// The total amount of tokens in accounts
-            total_account_balances: u64,
-            /// The total amount of tokens locked in subnets
-            total_subnet_locked: u64,
-        },
         /// a member of the senate is adjusted
         SenateAdjusted {
             /// the account ID of the old senate member, if any

pallets/subtensor/src/lib.rs

@@ -1445,39 +1445,7 @@ pub mod pallet {
 
         #[cfg(feature = "try-runtime")]
         fn try_state(_n: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
-            use frame_support::traits::fungible::Inspect;
-            use sp_runtime::Saturating;
-
-            // Assert [`TotalStake`] accounting is correct
-            let mut total_staked = 0;
-            for stake in Stake::<T>::iter() {
-                total_staked.saturating_accrue(stake.2);
-            }
-            ensure!(
-                total_staked == TotalStake::<T>::get(),
-                "TotalStake does not match total staked"
-            );
-
-            // Assert [`TotalSubnetLocked`] accounting is correct
-            let mut total_subnet_locked = 0;
-            for (_, locked) in SubnetLocked::<T>::iter() {
-                total_subnet_locked.saturating_accrue(locked);
-            }
-            ensure!(
-                total_subnet_locked == TotalSubnetLocked::<T>::get(),
-                "TotalSubnetLocked does not match total subnet locked"
-            );
-
-            // Assert [`TotalIssuance`] accounting is correct
-            let currency_issuance = T::Currency::total_issuance();
-            ensure!(
-                TotalIssuance::<T>::get()
-                    == currency_issuance
-                        .saturating_add(total_staked)
-                        .saturating_add(total_subnet_locked),
-                "TotalIssuance accounting discrepancy"
-            );
-
+            Self::check_accounting_invariants()?;
             Ok(())
         }
     }
@@ -2321,42 +2289,6 @@ pub mod pallet {
         ) -> DispatchResult {
             Ok(())
         }
-
-        /// Set the [`TotalIssuance`] storage value to the total account balances issued + the
-        /// total amount staked + the total amount locked in subnets.
-        #[pallet::call_index(67)]
-        #[pallet::weight((
-            Weight::default()
-                .saturating_add(T::DbWeight::get().reads(3))
-                .saturating_add(T::DbWeight::get().writes(1)),
-            DispatchClass::Normal,
-            Pays::Yes
-        ))]
-        pub fn rejig_total_issuance(origin: OriginFor<T>) -> DispatchResult {
-            let who = ensure_signed_or_root(origin)?;
-
-            let total_account_balances =
-                <T::Currency as fungible::Inspect<T::AccountId>>::total_issuance();
-            let total_stake = TotalStake::<T>::get();
-            let total_subnet_locked = TotalSubnetLocked::<T>::get();
-
-            let prev_total_issuance = TotalIssuance::<T>::get();
-            let new_total_issuance = total_account_balances
-                .saturating_add(total_stake)
-                .saturating_add(total_subnet_locked);
-            TotalIssuance::<T>::put(new_total_issuance);
-
-            Self::deposit_event(Event::TotalIssuanceRejigged {
-                who,
-                prev_total_issuance,
-                new_total_issuance,
-                total_stake,
-                total_account_balances,
-                total_subnet_locked,
-            });
-
-            Ok(())
-        }
     }
 
     // ---- Subtensor helper functions.
@@ -2402,6 +2334,46 @@ pub mod pallet {
             }
             true
         }
+
+        #[cfg(feature = "try-runtime")]
+        /// Assets [`TotalStake`], [`TotalSubnetLocked`], and [`TotalIssuance`] accounting invariants
+        /// are correct.
+        pub fn check_accounting_invariants() -> Result<(), sp_runtime::TryRuntimeError> {
+            use frame_support::traits::fungible::Inspect;
+            use sp_runtime::Saturating;
+
+            // Assert [`TotalStake`] accounting is correct
+            let mut total_staked = 0;
+            for stake in Stake::<T>::iter() {
+                total_staked.saturating_accrue(stake.2);
+            }
+            ensure!(
+                total_staked == TotalStake::<T>::get(),
+                "TotalStake does not match total staked"
+            );
+
+            // Assert [`TotalSubnetLocked`] accounting is correct
+            let mut total_subnet_locked = 0;
+            for (_, locked) in SubnetLocked::<T>::iter() {
+                total_subnet_locked.saturating_accrue(locked);
+            }
+            ensure!(
+                total_subnet_locked == TotalSubnetLocked::<T>::get(),
+                "TotalSubnetLocked does not match total subnet locked"
+            );
+
+            // Assert [`TotalIssuance`] accounting is correct
+            let currency_issuance = T::Currency::total_issuance();
+            ensure!(
+                TotalIssuance::<T>::get()
+                    == currency_issuance
+                        .saturating_add(total_staked)
+                        .saturating_add(total_subnet_locked),
+                "TotalIssuance accounting discrepancy"
+            );
+
+            Ok(())
+        }
     }
 }
 

pallets/subtensor/tests/root.rs

@@ -1,7 +1,6 @@
 #![allow(clippy::indexing_slicing, clippy::unwrap_used)]
 
 use crate::mock::*;
-use frame_support::traits::fungible::Mutate;
 use frame_support::{assert_err, assert_ok};
 use frame_system::Config;
 use frame_system::{EventRecord, Phase};
@@ -976,57 +975,6 @@ fn test_dissolve_network_does_not_exist_err() {
     });
 }
 
-#[test]
-fn test_rejig_total_issuance_ok() {
-    new_test_ext(1).execute_with(|| {
-        // Setup
-        let who = U256::from(1);
-        Balances::set_balance(&who, 100);
-        let balances_total_issuance = Balances::total_issuance();
-        assert!(balances_total_issuance > 0);
-        let total_stake = 100;
-        let total_subnet_locked = 1000;
-        pallet_subtensor::TotalSubnetLocked::<Test>::put(total_subnet_locked);
-        pallet_subtensor::TotalStake::<Test>::put(total_stake);
-
-        let expected_total_issuance = balances_total_issuance + total_stake + total_subnet_locked;
-
-        // Rejig total issuance
-        let total_issuance_before = pallet_subtensor::TotalIssuance::<Test>::get();
-        assert_ne!(total_issuance_before, expected_total_issuance);
-        assert_ok!(SubtensorModule::rejig_total_issuance(
-            RuntimeOrigin::signed(who)
-        ));
-        let total_issuance_after = pallet_subtensor::TotalIssuance::<Test>::get();
-
-        // Rejigged
-        assert_eq!(total_issuance_after, expected_total_issuance);
-        System::assert_last_event(RuntimeEvent::SubtensorModule(
-            pallet_subtensor::Event::TotalIssuanceRejigged {
-                who: Some(who),
-                new_total_issuance: total_issuance_after,
-                prev_total_issuance: total_issuance_before,
-                total_account_balances: balances_total_issuance,
-                total_stake,
-                total_subnet_locked,
-            },
-        ));
-
-        // Works with root
-        assert_ok!(SubtensorModule::rejig_total_issuance(RuntimeOrigin::root()));
-        System::assert_last_event(RuntimeEvent::SubtensorModule(
-            pallet_subtensor::Event::TotalIssuanceRejigged {
-                who: None,
-                new_total_issuance: total_issuance_after,
-                prev_total_issuance: total_issuance_after,
-                total_account_balances: balances_total_issuance,
-                total_stake,
-                total_subnet_locked,
-            },
-        ));
-    });
-}
-
 #[test]
 fn test_set_subnet_locked_balance_adjusts_total_subnet_locked_correctly() {
     new_test_ext(1).execute_with(|| {

runtime/src/lib.rs

@@ -1297,7 +1297,7 @@ pub type SignedExtra = (
     pallet_commitments::CommitmentsSignedExtension<Runtime>,
 );
 
-type Migrations = pallet_grandpa::migrations::MigrateV4ToV5<Runtime>;
+type Migrations = migrations::initialise_ti::Migration;
 
 // Unchecked extrinsic type as expected by this runtime.
 pub type UncheckedExtrinsic =

runtime/src/migrations/initialise_ti.rs

@@ -0,0 +1,46 @@
+use frame_support::traits::{fungible, OnRuntimeUpgrade};
+
+use crate::*;
+
+pub struct Migration;
+
+impl OnRuntimeUpgrade for Migration {
+    fn on_runtime_upgrade() -> Weight {
+        // First, we need to initialize the TotalSubnetLocked
+        let subnets_len = pallet_subtensor::SubnetLocked::<Runtime>::iter().count() as u64;
+        let total_subnet_locked: u64 = pallet_subtensor::SubnetLocked::<Runtime>::iter()
+            .fold(0, |acc, (_, v)| acc.saturating_add(v));
+        pallet_subtensor::TotalSubnetLocked::<Runtime>::put(total_subnet_locked);
+
+        // Now, we can rejig the total issuance
+        let total_account_balances =
+            <<Runtime as pallet_subtensor::Config>::Currency as fungible::Inspect<
+                <Runtime as frame_system::Config>::AccountId,
+            >>::total_issuance();
+        let total_stake = pallet_subtensor::TotalStake::<Runtime>::get();
+        let total_subnet_locked = pallet_subtensor::TotalSubnetLocked::<Runtime>::get();
+
+        let prev_total_issuance = pallet_subtensor::TotalIssuance::<Runtime>::get();
+        let new_total_issuance = total_account_balances
+            .saturating_add(total_stake)
+            .saturating_add(total_subnet_locked);
+        pallet_subtensor::TotalIssuance::<Runtime>::put(new_total_issuance);
+
+        log::info!(
+            "Subtensor Pallet TI Rejigged: previously: {:?}, new: {:?}",
+            prev_total_issuance,
+            new_total_issuance
+        );
+
+        <Runtime as frame_system::Config>::DbWeight::get()
+            .reads_writes(subnets_len.saturating_add(5), 1)
+    }
+
+    #[cfg(feature = "try-runtime")]
+    fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+        // These are usually checked anyway by try-runtime-cli, but just in case check them again
+        // explicitly here.
+        pallet_subtensor::Pallet::<Runtime>::check_accounting_invariants()?;
+        Ok(())
+    }
+}

runtime/src/migrations/mod.rs

@@ -1 +1,3 @@
 //! Export migrations from here.
+
+pub mod initialise_ti;