Merge remote-tracking branch 'origin/main' into devnet-ready

Author: sam0x17

pallets/subtensor/src/coinbase/run_coinbase.rs

@@ -124,6 +124,11 @@ impl<T: Config> Pallet<T> {
         let mut alpha_in: BTreeMap<NetUid, U96F32> = BTreeMap::new();
         let mut alpha_out: BTreeMap<NetUid, U96F32> = BTreeMap::new();
         let mut excess_tao: BTreeMap<NetUid, U96F32> = BTreeMap::new();
+        let tao_block_emission: U96F32 = U96F32::saturating_from_num(
+            Self::get_block_emission()
+                .unwrap_or(TaoCurrency::ZERO)
+                .to_u64(),
+        );
 
         // Only calculate for subnets that we are emitting to.
         for (&netuid_i, &tao_emission_i) in subnet_emissions.iter() {
@@ -142,8 +147,9 @@ impl<T: Config> Pallet<T> {
             let alpha_out_i: U96F32 = alpha_emission_i;
             let mut alpha_in_i: U96F32 = tao_emission_i.safe_div_or(price_i, U96F32::from_num(0.0));
 
-            if alpha_in_i > alpha_emission_i {
-                alpha_in_i = alpha_emission_i;
+            let alpha_injection_cap: U96F32 = alpha_emission_i.min(tao_block_emission);
+            if alpha_in_i > alpha_injection_cap {
+                alpha_in_i = alpha_injection_cap;
                 tao_in_i = alpha_in_i.saturating_mul(price_i);
             }
 

pallets/subtensor/src/tests/coinbase.rs

@@ -3980,3 +3980,39 @@ fn test_root_proportion() {
         assert_eq!(actual_root_proportion, expected_root_prop);
     });
 }
+
+#[test]
+fn test_get_subnet_terms_alpha_emissions_cap() {
+    new_test_ext(1).execute_with(|| {
+        let owner_hotkey = U256::from(10);
+        let owner_coldkey = U256::from(11);
+        let netuid = add_dynamic_network(&owner_hotkey, &owner_coldkey);
+        let tao_block_emission: U96F32 = U96F32::saturating_from_num(
+            SubtensorModule::get_block_emission()
+                .unwrap_or(TaoCurrency::ZERO)
+                .to_u64(),
+        );
+
+        // price = 1.0
+        // tao_block_emission = 1000000000
+        // tao_block_emission == alpha_emission_i
+        // alpha_in_i <= alpha_injection_cap
+        let emissions1 = U96F32::from_num(100_000_000);
+
+        let subnet_emissions1 = BTreeMap::from([(netuid, emissions1)]);
+        let (_, alpha_in, _, _) = SubtensorModule::get_subnet_terms(&subnet_emissions1);
+
+        assert_eq!(alpha_in.get(&netuid).copied().unwrap(), emissions1);
+
+        // price = 1.0
+        // tao_block_emission = 1000000000
+        // tao_block_emission == alpha_emission_i
+        // alpha_in_i > alpha_injection_cap
+        let emissions2 = U96F32::from_num(10_000_000_000u64);
+
+        let subnet_emissions2 = BTreeMap::from([(netuid, emissions2)]);
+        let (_, alpha_in, _, _) = SubtensorModule::get_subnet_terms(&subnet_emissions2);
+
+        assert_eq!(alpha_in.get(&netuid).copied().unwrap(), tao_block_emission);
+    });
+}

runtime/src/lib.rs

@@ -19,15 +19,15 @@ extern crate alloc;
 use codec::{Compact, Decode, Encode};
 use ethereum::AuthorizationList;
 use frame_support::{
-    PalletId,
     dispatch::DispatchResult,
     genesis_builder_helper::{build_state, get_preset},
     pallet_prelude::Get,
-    traits::{Contains, InsideBoth, LinearStoragePrice, fungible::HoldConsideration},
+    traits::{fungible::HoldConsideration, Contains, InsideBoth, LinearStoragePrice},
+    PalletId,
 };
 use frame_system::{EnsureRoot, EnsureRootWithSuccess, EnsureSigned};
 use pallet_commitments::{CanCommit, OnMetadataCommitment};
-use pallet_grandpa::{AuthorityId as GrandpaId, fg_primitives};
+use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId};
 use pallet_registry::CanRegisterIdentity;
 pub use pallet_shield;
 use pallet_subtensor::rpc_info::{
@@ -49,42 +49,44 @@ use sp_consensus_aura::sr25519::AuthorityId as AuraId;
 use sp_consensus_babe::BabeConfiguration;
 use sp_consensus_babe::BabeEpochConfiguration;
 use sp_core::{
-    H160, H256, OpaqueMetadata, U256,
     crypto::{ByteArray, KeyTypeId},
+    OpaqueMetadata, H160, H256, U256,
 };
-use sp_runtime::Cow;
 use sp_runtime::generic::Era;
+use sp_runtime::Cow;
 use sp_runtime::{
-    AccountId32, ApplyExtrinsicResult, ConsensusEngineId, Percent, generic, impl_opaque_keys,
+    generic, impl_opaque_keys,
     traits::{
         AccountIdLookup, BlakeTwo256, Block as BlockT, DispatchInfoOf, Dispatchable, One,
         PostDispatchInfoOf, UniqueSaturatedInto, Verify,
     },
     transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},
+    AccountId32, ApplyExtrinsicResult, ConsensusEngineId, Percent,
 };
 use sp_std::cmp::Ordering;
 use sp_std::prelude::*;
 #[cfg(feature = "std")]
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 use subtensor_precompiles::Precompiles;
-use subtensor_runtime_common::{AlphaCurrency, TaoCurrency, time::*, *};
+use subtensor_runtime_common::{time::*, AlphaCurrency, TaoCurrency, *};
 use subtensor_swap_interface::{Order, SwapHandler};
 
 // A few exports that help ease life for downstream crates.
 pub use frame_support::{
-    StorageValue, construct_runtime, parameter_types,
+    construct_runtime, parameter_types,
     traits::{
-        ConstBool, ConstU8, ConstU32, ConstU64, ConstU128, FindAuthor, InstanceFilter,
+        ConstBool, ConstU128, ConstU32, ConstU64, ConstU8, FindAuthor, InstanceFilter,
         KeyOwnerProofSystem, OnFinalize, OnTimestampSet, PrivilegeCmp, Randomness, StorageInfo,
     },
     weights::{
-        IdentityFee, Weight, WeightToFeeCoefficient, WeightToFeeCoefficients,
-        WeightToFeePolynomial,
         constants::{
             BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND,
         },
+        IdentityFee, Weight, WeightToFeeCoefficient, WeightToFeeCoefficients,
+        WeightToFeePolynomial,
     },
+    StorageValue,
 };
 pub use frame_system::Call as SystemCall;
 pub use pallet_balances::Call as BalancesCall;