add moving price tests

Author: unconst

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -47,7 +47,6 @@ impl<T: Config> Pallet<T> {
         let mut total_moving_prices: I96F32 = I96F32::from_num(0.0);
         for netuid_i in subnets.iter() {
             // Get and update the moving price of each subnet adding the total together.
-            Self::update_moving_price( *netuid_i );
             total_moving_prices = total_moving_prices.saturating_add( Self::get_moving_alpha_price( *netuid_i ) );
         }
         log::debug!("total_moving_prices: {:?}", total_moving_prices);
@@ -180,6 +179,12 @@ impl<T: Config> Pallet<T> {
             });
         }
 
+        // --- 7 Update moving prices after using them in the emission calculation.
+        for netuid_i in subnets.iter() {
+            // Update moving prices after using them above.
+            Self::update_moving_price( *netuid_i );
+        }
+
         // --- 7. Drain pending emission through the subnet based on tempo.
         for &netuid in subnets.iter() {
             // Pass on subnets that have not reached their tempo.

pallets/subtensor/src/tests/coinbase.rs

@@ -49,3 +49,137 @@ fn test_dynamic_function_various_values() {
     });
 }
 
+
+// Test the base case of running coinbase with zero emission.
+// This test verifies that the coinbase mechanism can handle the edge case
+// of zero emission without errors or unexpected behavior.
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_coinbase_basecase --exact --show-output --nocapture
+#[test]
+fn test_coinbase_basecase() {
+    new_test_ext(1).execute_with(|| {
+        SubtensorModule::run_coinbase( I96F32::from_num(0.0) );
+    });
+}
+
+// Test the emission distribution for a single subnet.
+// This test verifies that:
+// - A single subnet receives the full emission amount
+// - The emission is correctly reflected in SubnetTAO
+// - Total issuance and total stake are updated appropriately
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_coinbase_tao_issuance_base --exact --show-output --nocapture
+#[test]
+fn test_coinbase_tao_issuance_base() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        let emission: u64 = 1_234_567;
+        add_network(netuid, 1, 0);
+        assert_eq!( SubnetTAO::<Test>::get( netuid ), 0);
+        SubtensorModule::run_coinbase( I96F32::from_num( emission ) );
+        assert_eq!( SubnetTAO::<Test>::get( netuid ), emission);
+        assert_eq!( TotalIssuance::<Test>::get(), emission);
+        assert_eq!( TotalStake::<Test>::get(), emission);
+    });
+}
+
+// Test emission distribution across multiple subnets.
+// This test verifies that:
+// - Multiple subnets receive equal portions of the total emission
+// - Each subnet's TAO balance is updated correctly
+// - Total issuance and total stake reflect the full emission amount
+// - The emission is split evenly between all subnets
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_coinbase_tao_issuance_multiple --exact --show-output --nocapture
+#[test]
+fn test_coinbase_tao_issuance_multiple() {
+    new_test_ext(1).execute_with(|| {
+        let netuid1: u16 = 1;
+        let netuid2: u16 = 2;
+        let netuid3: u16 = 3;
+        let emission: u64 = 3_333_333;
+        add_network(netuid1, 1, 0);
+        add_network(netuid2, 1, 0);
+        add_network(netuid3, 1, 0);
+        assert_eq!( SubnetTAO::<Test>::get( netuid1 ), 0);
+        assert_eq!( SubnetTAO::<Test>::get( netuid2 ), 0);
+        assert_eq!( SubnetTAO::<Test>::get( netuid3 ), 0);
+        SubtensorModule::run_coinbase( I96F32::from_num( emission ) );
+        assert_eq!( SubnetTAO::<Test>::get( netuid1 ), emission/3);
+        assert_eq!( SubnetTAO::<Test>::get( netuid2 ), emission/3);
+        assert_eq!( SubnetTAO::<Test>::get( netuid3 ), emission/3);
+        assert_eq!( TotalIssuance::<Test>::get(), emission);
+        assert_eq!( TotalStake::<Test>::get(), emission);
+    });
+}
+
+// Test emission distribution with different subnet prices.
+// This test verifies that:
+// - Subnets with different prices receive proportional emission shares
+// - A subnet with double the price receives double the emission
+// - Total issuance and total stake reflect the full emission amount
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_coinbase_tao_issuance_different_prices --exact --show-output --nocapture
+#[test]
+fn test_coinbase_tao_issuance_different_prices() {
+    new_test_ext(1).execute_with(|| {
+        let netuid1: u16 = 1;
+        let netuid2: u16 = 2;
+        let emission: u64 = 100_000_000;
+        add_network(netuid1, 1, 0);
+        add_network(netuid2, 1, 0);
+        // Make subnets dynamic.
+        SubnetMechanism::<Test>::insert(netuid1, 1);
+        SubnetMechanism::<Test>::insert(netuid2, 1);
+        // Set subnet prices.
+        SubnetMovingPrice::<Test>::insert( netuid1, I96F32::from_num(1) );
+        SubnetMovingPrice::<Test>::insert( netuid2, I96F32::from_num(2) );
+        // Assert initial TAO reserves.
+        assert_eq!( SubnetTAO::<Test>::get( netuid1 ), 0);
+        assert_eq!( SubnetTAO::<Test>::get( netuid2 ), 0);
+        // Run the coinbase with the emission amount.
+        SubtensorModule::run_coinbase( I96F32::from_num( emission ) );
+        // Assert tao emission is split evenly.
+        assert_eq!( SubnetTAO::<Test>::get( netuid1 ), emission/3 );
+        assert_eq!( SubnetTAO::<Test>::get( netuid2 ), emission/3 + emission/3);
+        close( TotalIssuance::<Test>::get(), emission, 2);
+        close( TotalStake::<Test>::get(), emission, 2);
+    });
+}
+
+// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_coinbase_moving_prices --exact --show-output --nocapture
+#[test]
+fn test_coinbase_moving_prices() {
+    new_test_ext(1).execute_with(|| {
+        let netuid: u16 = 1;
+        add_network(netuid, 1, 0);
+        // Set price to 1.0
+        SubnetTAO::<Test>::insert(netuid, 1_000_000);
+        SubnetAlphaIn::<Test>::insert(netuid, 1_000_000);
+        SubnetMechanism::<Test>::insert(netuid, 1);
+        SubnetMovingPrice::<Test>::insert( netuid, I96F32::from_num(1) );
+        // Updating the moving price keeps it the same.
+        assert_eq!( SubtensorModule::get_moving_alpha_price(netuid), I96F32::from_num(1) );
+        SubtensorModule::update_moving_price( netuid );
+        assert_eq!( SubtensorModule::get_moving_alpha_price(netuid), I96F32::from_num(1) );
+        // Check alpha of 1.
+        // Set price to zero.
+        SubnetMovingPrice::<Test>::insert( netuid, I96F32::from_num(0) );
+        SubnetMovingAlpha::<Test>::set( I96F32::from_num(1.0) );
+        // Run moving 1 times.
+        SubtensorModule::update_moving_price( netuid );
+        // Assert price is == 100% of the real price.
+        assert_eq!( SubtensorModule::get_moving_alpha_price(netuid), I96F32::from_num(1.0) );
+        // Set price to zero.
+        SubnetMovingPrice::<Test>::insert( netuid, I96F32::from_num(0) );
+        SubnetMovingAlpha::<Test>::set( I96F32::from_num(0.1) );
+        // Run moving 6 times.
+        SubtensorModule::update_moving_price( netuid );
+        SubtensorModule::update_moving_price( netuid );
+        SubtensorModule::update_moving_price( netuid );
+        SubtensorModule::update_moving_price( netuid );
+        SubtensorModule::update_moving_price( netuid );
+        SubtensorModule::update_moving_price( netuid );
+        // Assert price is > 50% of the real price.
+        assert_eq!( SubtensorModule::get_moving_alpha_price(netuid), I96F32::from_num(0.468559) );
+    });
+}
+
+
+