diff --git a/pallets/subtensor/src/coinbase/run_coinbase.rs b/pallets/subtensor/src/coinbase/run_coinbase.rs index d42f90ec98..e699c62da1 100644 --- a/pallets/subtensor/src/coinbase/run_coinbase.rs +++ b/pallets/subtensor/src/coinbase/run_coinbase.rs @@ -187,11 +187,6 @@ impl Pallet { let mut alpha_in: BTreeMap = BTreeMap::new(); let mut alpha_out: BTreeMap = BTreeMap::new(); let mut excess_tao: BTreeMap = BTreeMap::new(); - let tao_block_emission: U96F32 = U96F32::saturating_from_num( - Self::calculate_block_emission() - .unwrap_or(TaoBalance::ZERO) - .to_u64(), - ); // Only calculate for subnets that we are emitting to. for (&netuid_i, &tao_emission_i) in subnet_emissions.iter() { @@ -211,7 +206,14 @@ impl Pallet { 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)); - let alpha_injection_cap: U96F32 = alpha_emission_i.min(tao_block_emission); + // Cap alpha injection by the subnet's root proportion of its alpha emission. + // root_proportion = tao_weight / (tao_weight + alpha_issuance), so as a subnet + // ages its alpha issuance grows, root_proportion shrinks, and the injection cap + // falls. The TAO emission that can no longer be injected as liquidity becomes + // excess TAO and is routed into chain buys instead. This is what transitions + // older subnets from liquidity injection to chain buys over time. + let root_proportion_i: U96F32 = Self::root_proportion(netuid_i); + let alpha_injection_cap: U96F32 = root_proportion_i.saturating_mul(alpha_emission_i); if alpha_in_i > alpha_injection_cap { alpha_in_i = alpha_injection_cap; tao_in_i = alpha_in_i.saturating_mul(price_i); diff --git a/pallets/subtensor/src/coinbase/subnet_emissions.rs b/pallets/subtensor/src/coinbase/subnet_emissions.rs index 6ff188f362..caab671ed4 100644 --- a/pallets/subtensor/src/coinbase/subnet_emissions.rs +++ b/pallets/subtensor/src/coinbase/subnet_emissions.rs @@ -347,14 +347,16 @@ impl Pallet { offset_flows } - // Combines ema price method and tao flow method linearly over FlowHalfLife blocks + // Price-based emission shares: each subnet's share is its EMA price normalized + // by the sum of EMA prices. Emit-disabled subnets are zeroed and their share + // redistributed to enabled subnets in `get_subnet_block_emissions`, so the + // effective emission is e_i = p_i / sum(p_j) over emit-enabled subnets. pub(crate) fn get_shares(subnets_to_emit_to: &[NetUid]) -> BTreeMap { - Self::get_shares_flow(subnets_to_emit_to) - // Self::get_shares_price_ema(subnets_to_emit_to) + Self::get_shares_price_ema(subnets_to_emit_to) } - // DEPRECATED: Implementation of shares that uses EMA prices will be gradually deprecated - #[allow(dead_code)] + // Implementation of shares that uses subnet EMA prices (SubnetMovingPrice), + // not the active/spot alpha price. fn get_shares_price_ema(subnets_to_emit_to: &[NetUid]) -> BTreeMap { // Get sum of alpha moving prices let total_moving_prices = subnets_to_emit_to diff --git a/pallets/subtensor/src/tests/claim_root.rs b/pallets/subtensor/src/tests/claim_root.rs index 7b40c4d372..12606c5266 100644 --- a/pallets/subtensor/src/tests/claim_root.rs +++ b/pallets/subtensor/src/tests/claim_root.rs @@ -1162,11 +1162,15 @@ fn test_claim_root_coinbase_distribution() { run_to_block(2); let alpha_issuance = SubtensorModule::get_alpha_issuance(netuid); - // We went two blocks so we should have 2x the alpha emissions - assert_eq!( - initial_alpha_issuance + alpha_emissions.saturating_mul(2.into()), - alpha_issuance - ); + // Net issuance grows by the block alpha emission (alpha_out) plus the + // root-proportion-capped alpha injection. Chain buys move alpha between the + // pool reserve and outstanding supply without changing net issuance, and with + // this subnet's small root proportion the injection is well under a second + // full emission. + let issuance_growth = + u64::from(alpha_issuance).saturating_sub(u64::from(initial_alpha_issuance)); + assert!(issuance_growth >= u64::from(alpha_emissions)); + assert!(issuance_growth < u64::from(alpha_emissions.saturating_mul(2.into()))); let root_prop = initial_tao as f64 / (u64::from(alpha_issuance) + initial_tao) as f64; let root_validators_share = 0.5f64; diff --git a/pallets/subtensor/src/tests/coinbase.rs b/pallets/subtensor/src/tests/coinbase.rs index 02d1865905..cf8f34d1c7 100644 --- a/pallets/subtensor/src/tests/coinbase.rs +++ b/pallets/subtensor/src/tests/coinbase.rs @@ -28,6 +28,19 @@ fn close(value: u64, target: u64, eps: u64) { ) } +/// Seed a large root stake with full TAO weight so that +/// `root_proportion = tao_weight / (tao_weight + alpha_issuance)` is ~1. +/// This keeps the alpha-injection cap (`root_proportion * alpha_emission`) from +/// spuriously binding for small per-subnet emissions, preserving the liquidity +/// injection behavior these tests were written for. +fn set_full_injection_root_stake() { + SubnetTAO::::insert( + NetUid::ROOT, + TaoBalance::from(1_000_000_000_000_000_000_u64), + ); + SubtensorModule::set_tao_weight(u64::MAX); +} + // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::coinbase::test_hotkey_take --exact --show-output --nocapture #[test] fn test_hotkey_take() { @@ -68,9 +81,11 @@ fn test_coinbase_tao_issuance_base() { let subnet_owner_ck = U256::from(1001); let subnet_owner_hk = U256::from(1002); let netuid = add_dynamic_network(&subnet_owner_hk, &subnet_owner_ck); + // Price-based emission shares require a non-zero moving price. + SubnetMovingPrice::::insert(netuid, I96F32::from_num(1)); + // Keep root_proportion ~1 so the injection cap does not bind. + set_full_injection_root_stake(); let total_issuance_before = TotalIssuance::::get(); - // Set subnet TAO flow to non-zero - SubnetTaoFlow::::insert(netuid, 1234567_i64); let tao_in_before = SubnetTAO::::get(netuid); let total_stake_before = TotalStake::::get(); let emission_credit = SubtensorModule::mint_tao(emission); @@ -246,43 +261,6 @@ fn test_coinbase_disabled_subnet_emission_redistributes_tao_to_enabled_subnets() }); } -#[test] -fn test_net_tao_flow_disabled_still_drains_protocol_flow_into_ema() { - new_test_ext(1).execute_with(|| { - let netuid1 = NetUid::from(1); - let netuid2 = NetUid::from(2); - - add_network(netuid1, 1, 0); - add_network(netuid2, 1, 0); - - NetTaoFlowEnabled::::set(false); - FlowEmaSmoothingFactor::::set(i64::MAX as u64); - - SubnetTaoFlow::::insert(netuid1, 1_000_i64); - SubnetTaoFlow::::insert(netuid2, 1_000_i64); - SubtensorModule::record_protocol_inflow(netuid1, 700.into()); - SubtensorModule::record_protocol_outflow(netuid2, 300.into()); - - System::set_block_number(1); - - SubtensorModule::get_subnet_block_emissions( - &[netuid1, netuid2], - U96F32::saturating_from_num(1_000_000u64), - ); - - assert_eq!(SubnetProtocolFlow::::get(netuid1), 0); - assert_eq!(SubnetProtocolFlow::::get(netuid2), 0); - assert_eq!( - SubnetEmaProtocolFlow::::get(netuid1), - Some((1, I64F64::from_num(700))) - ); - assert_eq!( - SubnetEmaProtocolFlow::::get(netuid2), - Some((1, I64F64::from_num(-300))) - ); - }); -} - #[test] fn test_sudo_set_subnet_emission_enabled_multiple_subnets_multiple_toggles() { new_test_ext(1).execute_with(|| { @@ -295,9 +273,9 @@ fn test_sudo_set_subnet_emission_enabled_multiple_subnets_multiple_toggles() { add_network(netuid2, 1, 0); add_network(netuid3, 1, 0); - SubnetTaoFlow::::insert(netuid1, 100_000_000_i64); - SubnetTaoFlow::::insert(netuid2, 100_000_000_i64); - SubnetTaoFlow::::insert(netuid3, 100_000_000_i64); + // Keep root_proportion ~1 so TAO-side emission is injected (populating + // SubnetTaoInEmission) rather than routed entirely to chain buys. + set_full_injection_root_stake(); let assert_emission_storage = |expected1: u64, expected2: u64, expected3: u64| { assert_abs_diff_eq!( @@ -403,10 +381,12 @@ fn test_coinbase_tao_issuance_different_prices() { SubnetMechanism::::insert(netuid1, 1); SubnetMechanism::::insert(netuid2, 1); - // Set subnet flows - // Subnet 2 has twice the flow of subnet 1. - SubnetTaoFlow::::insert(netuid1, 100_000_000_i64); - SubnetTaoFlow::::insert(netuid2, 200_000_000_i64); + // Price-based shares: subnet 2 has twice the moving price of subnet 1, + // so it should receive twice the TAO emission. + SubnetMovingPrice::::insert(netuid1, I96F32::from_num(0.1)); + SubnetMovingPrice::::insert(netuid2, I96F32::from_num(0.2)); + // Keep root_proportion ~1 so the injection cap does not bind. + set_full_injection_root_stake(); // Assert initial TAO reserves. assert_eq!(SubnetTAO::::get(netuid1), initial_tao.into()); @@ -642,9 +622,8 @@ fn test_coinbase_alpha_issuance_base() { SubnetAlphaIn::::insert(netuid1, AlphaBalance::from(initial)); SubnetTAO::::insert(netuid2, TaoBalance::from(initial)); SubnetAlphaIn::::insert(netuid2, AlphaBalance::from(initial)); - // Equal flow - SubnetTaoFlow::::insert(netuid1, 100_000_000_i64); - SubnetTaoFlow::::insert(netuid2, 100_000_000_i64); + // Keep root_proportion ~1 so the injection cap does not bind. + set_full_injection_root_stake(); // Check initial SubtensorModule::run_coinbase(emission_credit); // tao_in = 500_000 @@ -684,10 +663,11 @@ fn test_coinbase_alpha_issuance_different() { SubnetAlphaIn::::insert(netuid1, AlphaBalance::from(initial)); SubnetTAO::::insert(netuid2, TaoBalance::from(2 * initial)); SubnetAlphaIn::::insert(netuid2, AlphaBalance::from(initial)); - // Set subnet TAO flows to non-zero and 1:2 ratio - SubnetTaoFlow::::insert(netuid1, 100_000_000_i64); - SubnetTaoFlow::::insert(netuid2, 200_000_000_i64); - // Do NOT Set tao flow, let it initialize + // Price-based shares with prices 1 and 2 (1:2 ratio). + SubnetMovingPrice::::insert(netuid1, I96F32::from_num(1)); + SubnetMovingPrice::::insert(netuid2, I96F32::from_num(2)); + // Keep root_proportion ~1 so the injection cap does not bind. + set_full_injection_root_stake(); // Run coinbase SubtensorModule::run_coinbase(emission_credit); // tao_in = 333_333 @@ -728,16 +708,23 @@ fn test_coinbase_alpha_issuance_with_cap_trigger() { // Set subnet prices. SubnetMovingPrice::::insert(netuid1, I96F32::from_num(1)); SubnetMovingPrice::::insert(netuid2, I96F32::from_num(2)); + // Keep root_proportion ~1 so the injection cap binds at alpha_emission. + set_full_injection_root_stake(); // Run coinbase SubtensorModule::run_coinbase(emission_credit); - // tao_in = 333_333 - // alpha_in = 333_333/price > 1_000_000_000 --> 1_000_000_000 + initial_alpha + // alpha_in is capped at the injection cap, so injected alpha stays below + // a full block emission on top of the initial reserve. assert!(SubnetAlphaIn::::get(netuid1) < (initial_alpha + 1_000_000_000).into()); - assert_eq!(SubnetAlphaOut::::get(netuid2), 1_000_000_000.into()); - // tao_in = 666_666 - // alpha_in = 666_666/price > 1_000_000_000 --> 1_000_000_000 + initial_alpha + // Per-block alpha emission is the full block emission regardless of the cap. + assert_eq!( + SubnetAlphaOutEmission::::get(netuid1), + 1_000_000_000.into() + ); assert!(SubnetAlphaIn::::get(netuid2) < (initial_alpha + 1_000_000_000).into()); - assert_eq!(SubnetAlphaOut::::get(netuid2), 1_000_000_000.into()); // Gets full block emission. + assert_eq!( + SubnetAlphaOutEmission::::get(netuid2), + 1_000_000_000.into() + ); // Gets full block emission. }); } @@ -765,9 +752,10 @@ fn test_coinbase_alpha_issuance_with_cap_trigger_and_block_emission() { // Enable emission FirstEmissionBlockNumber::::insert(netuid1, 0); FirstEmissionBlockNumber::::insert(netuid2, 0); - // Set subnet TAO flows to non-zero and 1:2 ratio - SubnetTaoFlow::::insert(netuid1, 100_000_000_i64); - SubnetTaoFlow::::insert(netuid2, 200_000_000_i64); + // Price-based shares (1:2 ratio). Low pool prices mean alpha_in exceeds the + // injection cap, so the surplus TAO is spent on chain buys. + SubnetMovingPrice::::insert(netuid1, I96F32::from_num(1)); + SubnetMovingPrice::::insert(netuid2, I96F32::from_num(2)); // Force the swap to initialize ::SwapInterface::init_swap(netuid1, None); @@ -2671,6 +2659,11 @@ fn test_distribute_emission_zero_emission() { Incentive::::remove(NetUidStorageIndex::from(netuid)); Dividends::::remove(netuid); + // Capture stake right before the zero-emission distribution so the assertion + // isolates that call (the subnet legitimately accrues emission during the + // preceding block runs under price-based shares). + let stake_before_distribute = SubtensorModule::get_total_stake_for_hotkey(&hotkey); + // Set the emission to be ZERO. SubtensorModule::distribute_emission( netuid, @@ -2682,8 +2675,8 @@ fn test_distribute_emission_zero_emission() { // Get the new stake of the hotkey. let new_stake = SubtensorModule::get_total_stake_for_hotkey(&hotkey); - // We expect the stake to remain unchanged. - assert_eq!(new_stake, init_stake.into()); + // We expect the stake to remain unchanged by the zero-emission distribution. + assert_eq!(new_stake, stake_before_distribute); // Check that the incentive and dividends are set by epoch. assert!( @@ -3554,11 +3547,17 @@ fn test_coinbase_subnet_terms_with_alpha_in_gt_alpha_emission() { let subnet_emissions = BTreeMap::from([(netuid0, tao_emission)]); + // The injection cap is root_proportion * alpha_emission. Seed root stake so + // root_proportion is well-defined and the cap is positive. + set_full_injection_root_stake(); + let root_prop: U96F32 = SubtensorModule::root_proportion(netuid0); + let injection_cap: U96F32 = root_prop.saturating_mul(alpha_emission); + let (tao_in, alpha_in, alpha_out, excess_tao) = SubtensorModule::get_subnet_terms(&subnet_emissions); - // Check our condition is met - assert!(tao_emission / price_to_set_fixed > alpha_emission); + // Check our condition is met: the raw alpha_in exceeds the cap, so it binds. + assert!(tao_emission / price_to_set_fixed > injection_cap); // alpha_out should be the alpha_emission, always assert_abs_diff_eq!( @@ -3567,11 +3566,11 @@ fn test_coinbase_subnet_terms_with_alpha_in_gt_alpha_emission() { epsilon = 0.01 ); - // alpha_in should equal the alpha_emission + // alpha_in should be capped at root_proportion * alpha_emission assert_abs_diff_eq!( alpha_in[&netuid0].to_num::(), - alpha_emission.to_num::(), - epsilon = 0.01 + injection_cap.to_num::(), + epsilon = injection_cap.to_num::() / 1_000.0 ); // tao_in should be the alpha_in at the ratio of the price assert_abs_diff_eq!( @@ -3616,11 +3615,17 @@ fn test_coinbase_subnet_terms_with_alpha_in_lte_alpha_emission() { let subnet_emissions = BTreeMap::from([(netuid0, tao_emission)]); + // The injection cap is root_proportion * alpha_emission. Seed root stake so + // the cap is large enough that raw alpha_in stays under it (no excess). + set_full_injection_root_stake(); + let root_prop: U96F32 = SubtensorModule::root_proportion(netuid0); + let injection_cap: U96F32 = root_prop.saturating_mul(alpha_emission); + let (tao_in, alpha_in, alpha_out, excess_tao) = SubtensorModule::get_subnet_terms(&subnet_emissions); - // Check our condition is met - assert!(tao_emission / price <= alpha_emission); + // Check our condition is met: raw alpha_in stays under the cap. + assert!(tao_emission / price <= injection_cap); // alpha_out should be the alpha_emission, always assert_abs_diff_eq!( @@ -4239,33 +4244,36 @@ fn test_get_subnet_terms_alpha_emissions_cap() { 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::calculate_block_emission() - .unwrap_or(TaoBalance::ZERO) - .to_u64(), + + // The injection cap is now root_proportion * alpha_emission. Seed root stake + // so root_proportion is well-defined, and derive the cap from the live values. + set_full_injection_root_stake(); + let alpha_emission_i: U96F32 = U96F32::saturating_from_num( + SubtensorModule::get_block_emission_for_issuance( + SubtensorModule::get_alpha_issuance(netuid).into(), + ) + .unwrap_or(0), ); + let injection_cap: U96F32 = + SubtensorModule::root_proportion(netuid).saturating_mul(alpha_emission_i); - // price = 1.0 - // tao_block_emission = 1000000000 - // tao_block_emission == alpha_emission_i - // alpha_in_i <= alpha_injection_cap + // price = 1.0, alpha_in_i (== emissions1) <= alpha_injection_cap (not capped) let emissions1 = U96F32::from_num(100_000_000); + assert!(emissions1 < injection_cap); 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 + // price = 1.0, alpha_in_i (== emissions2) > alpha_injection_cap (capped) let emissions2 = U96F32::from_num(10_000_000_000u64); + assert!(emissions2 > injection_cap); 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); + assert_eq!(alpha_in.get(&netuid).copied().unwrap(), injection_cap); }); } diff --git a/pallets/subtensor/src/tests/subnet_emissions.rs b/pallets/subtensor/src/tests/subnet_emissions.rs index 060171d5c7..4bb1aa4c75 100644 --- a/pallets/subtensor/src/tests/subnet_emissions.rs +++ b/pallets/subtensor/src/tests/subnet_emissions.rs @@ -151,126 +151,6 @@ fn inplace_pow_normalize_fractional_exponent() { }) } -#[allow(clippy::expect_used)] -#[test] -fn protocol_normalization_keeps_eligible_subnet_count_from_collapsing() { - new_test_ext(1).execute_with(|| { - let subnet_count = 70usize; - let user_flow = 100u64; - let protocol_flow_start = 40u64; - let protocol_flow_step = 4u64; - - NetTaoFlowEnabled::::set(true); - FlowNormExponent::::set(u64f64(1.0)); - TaoFlowCutoff::::set(i64f64(0.0)); - FlowEmaSmoothingFactor::::set(i64::MAX as u64); - - let subnets = (0..subnet_count) - .map(|i| { - let netuid = NetUid::from((i + 1) as u16); - add_network(netuid, 360, 0); - SubnetEmissionEnabled::::insert(netuid, true); - - let protocol_flow = protocol_flow_start + protocol_flow_step.saturating_mul(i as u64); - SubtensorModule::record_tao_inflow(netuid, TaoBalance::from(user_flow)); - SubtensorModule::record_protocol_inflow(netuid, TaoBalance::from(protocol_flow)); - - netuid - }) - .collect::>(); - - let subnets_to_emit_to = SubtensorModule::get_subnets_to_emit_to(&subnets); - assert_eq!( - subnets_to_emit_to.len(), - subnets.len(), - "test setup should make every subnet structurally eligible before flow scoring" - ); - - let emissions = SubtensorModule::get_subnet_block_emissions( - &subnets_to_emit_to, - U96F32::saturating_from_num(1_000_000_000u64), - ); - - let ema_rows = subnets_to_emit_to - .iter() - .map(|netuid| { - let (_, user_ema) = SubnetEmaTaoFlow::::get(*netuid) - .expect("user EMA should be initialized by get_subnet_block_emissions"); - let (_, protocol_ema) = SubnetEmaProtocolFlow::::get(*netuid) - .expect("protocol EMA should be initialized by get_subnet_block_emissions"); - - (*netuid, user_ema.to_num::(), protocol_ema.to_num::()) - }) - .collect::>(); - - let positive_user_ema_count = ema_rows - .iter() - .filter(|(_, user_ema, _)| *user_ema > 0.0) - .count(); - let dynamic_eligibility_floor = positive_user_ema_count / 2; - - let sum_positive_user_ema: f64 = ema_rows - .iter() - .map(|(_, user_ema, _)| (*user_ema).max(0.0)) - .sum(); - let sum_positive_protocol_ema: f64 = ema_rows - .iter() - .map(|(_, _, protocol_ema)| (*protocol_ema).max(0.0)) - .sum(); - let protocol_norm_factor = if sum_positive_protocol_ema > 0.0 { - (sum_positive_user_ema / sum_positive_protocol_ema).min(1.0) - } else { - 0.0 - }; - - let unnormalized_eligible = ema_rows - .iter() - .filter(|(_, user_ema, protocol_ema)| *user_ema > *protocol_ema) - .count(); - let expected_normalized_eligible = ema_rows - .iter() - .filter(|(_, user_ema, protocol_ema)| { - let scaled_protocol_ema = if *protocol_ema > 0.0 { - protocol_norm_factor * *protocol_ema - } else { - *protocol_ema - }; - *user_ema > scaled_protocol_ema - }) - .count(); - let actual_eligible = emissions - .values() - .filter(|emission| emission.to_num::() > 0.0) - .count(); - let total_emission: f64 = emissions - .values() - .map(|emission| emission.to_num::()) - .sum(); - - assert_abs_diff_eq!(total_emission, 1_000_000_000.0_f64, epsilon = 1.0); - assert!( - unnormalized_eligible < dynamic_eligibility_floor, - "test setup should reproduce the old unnormalized collapse: unnormalized_eligible={unnormalized_eligible}, dynamic_eligibility_floor={dynamic_eligibility_floor}" - ); - assert!( - expected_normalized_eligible >= dynamic_eligibility_floor, - "test setup should keep enough subnets eligible after protocol normalization: expected_normalized_eligible={expected_normalized_eligible}, dynamic_eligibility_floor={dynamic_eligibility_floor}" - ); - assert_eq!( - actual_eligible, expected_normalized_eligible, - "eligible subnet count should be derived from the normalized protocol-cost calculation" - ); - assert!( - actual_eligible >= dynamic_eligibility_floor, - "eligible subnet count collapsed below the dynamic floor: actual_eligible={actual_eligible}, dynamic_eligibility_floor={dynamic_eligibility_floor}, unnormalized_eligible={unnormalized_eligible}" - ); - assert!( - actual_eligible > unnormalized_eligible, - "normalization should preserve more eligible subnets than the old unnormalized path: actual_eligible={actual_eligible}, unnormalized_eligible={unnormalized_eligible}" - ); - }); -} - // /// Normal (moderate, non-zero) EMA flows across 3 subnets. // /// Expect: shares sum to ~1 and are monotonic with flows. // #[test] diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index f18065f75c..b6be89efe8 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 420, + spec_version: 421, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1,