merge with target branch

Author: open-junius

Cargo.lock

@@ -95,7 +95,6 @@ substrate-prometheus-endpoint = { workspace = true }
 fc-storage = { workspace = true }
 fc-db = { workspace = true }
 fc-consensus = { workspace = true }
-fp-dynamic-fee = { workspace = true }
 fc-api = { workspace = true }
 fc-rpc = { workspace = true }
 fc-rpc-core = { workspace = true }

node/Cargo.toml

@@ -56,10 +56,6 @@ pub struct EthConfiguration {
     #[arg(long)]
     pub enable_dev_signer: bool,
 
-    /// The dynamic-fee pallet target gas price set by block author
-    #[arg(long, default_value = "1")]
-    pub target_gas_price: u64,
-
     /// Maximum allowed gas limit will be `block.gas_limit * execute_gas_limit_multiplier`
     /// when using eth_call/eth_estimateGas.
     #[arg(long, default_value = "10")]

node/src/ethereum.rs

@@ -19,7 +19,6 @@ use sp_api::ProvideRuntimeApi;
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
 use sp_consensus::Error as ConsensusError;
 use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
-use sp_core::U256;
 use sp_runtime::traits::{Block as BlockT, Header, NumberFor};
 use std::{cell::RefCell, path::Path};
 use std::{marker::PhantomData, sync::Arc, time::Duration};
@@ -279,7 +278,7 @@ where
 pub fn build_aura_grandpa_import_queue(
     client: Arc<FullClient>,
     config: &Configuration,
-    eth_config: &EthConfiguration,
+    _eth_config: &EthConfiguration,
     task_manager: &TaskManager,
     telemetry: Option<TelemetryHandle>,
     grandpa_block_import: GrandpaBlockImport,
@@ -294,16 +293,14 @@ where
     );
 
     let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
-    let target_gas_price = eth_config.target_gas_price;
     let create_inherent_data_providers = move |_, ()| async move {
         let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
         let slot =
             sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
                 *timestamp,
                 slot_duration,
             );
-        let dynamic_fee = fp_dynamic_fee::InherentDataProvider(U256::from(target_gas_price));
-        Ok((slot, timestamp, dynamic_fee))
+        Ok((slot, timestamp))
     };
 
     let import_queue = sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(
@@ -521,7 +518,6 @@ where
         ));
 
         let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
-        let target_gas_price = eth_config.target_gas_price;
         let pending_create_inherent_data_providers = move |_, ()| async move {
             let current = sp_timestamp::InherentDataProvider::from_system_time();
             let next_slot = current
@@ -533,8 +529,7 @@ where
 				*timestamp,
 				slot_duration,
 			);
-            let dynamic_fee = fp_dynamic_fee::InherentDataProvider(U256::from(target_gas_price));
-            Ok((slot, timestamp, dynamic_fee))
+            Ok((slot, timestamp))
         };
 
         Box::new(move |subscription_task_executor| {
@@ -613,7 +608,6 @@ where
         // manual-seal authorship
         if let Some(sealing) = sealing {
             run_manual_seal_authorship(
-                &eth_config,
                 sealing,
                 client,
                 transaction_pool,
@@ -639,15 +633,13 @@ where
         );
 
         let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
-        let target_gas_price = eth_config.target_gas_price;
         let create_inherent_data_providers = move |_, ()| async move {
             let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
             let slot = sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
 				*timestamp,
 				slot_duration,
 			);
-            let dynamic_fee = fp_dynamic_fee::InherentDataProvider(U256::from(target_gas_price));
-            Ok((slot, timestamp, dynamic_fee))
+            Ok((slot, timestamp))
         };
 
         let aura = sc_consensus_aura::start_aura::<AuraPair, _, _, _, _, _, _, _, _, _, _>(
@@ -770,7 +762,6 @@ pub fn new_chain_ops(
 
 #[allow(clippy::too_many_arguments)]
 fn run_manual_seal_authorship(
-    eth_config: &EthConfiguration,
     sealing: Sealing,
     client: Arc<FullClient>,
     transaction_pool: Arc<FullPool<Block, FullClient>>,
@@ -820,12 +811,8 @@ fn run_manual_seal_authorship(
         }
     }
 
-    let target_gas_price = eth_config.target_gas_price;
-    let create_inherent_data_providers = move |_, ()| async move {
-        let timestamp = MockTimestampInherentDataProvider;
-        let dynamic_fee = fp_dynamic_fee::InherentDataProvider(U256::from(target_gas_price));
-        Ok((timestamp, dynamic_fee))
-    };
+    let create_inherent_data_providers =
+        move |_, ()| async move { Ok(MockTimestampInherentDataProvider) };
 
     let manual_seal = match sealing {
         Sealing::Manual => future::Either::Left(sc_consensus_manual_seal::run_manual_seal(

node/src/service.rs

@@ -1887,6 +1887,8 @@ where
                     *origin_netuid,
                     *destination_netuid,
                     *alpha_amount,
+                    *alpha_amount,
+                    None,
                 ))
             }
             Some(Call::transfer_stake {
@@ -1905,6 +1907,8 @@ where
                     *origin_netuid,
                     *destination_netuid,
                     *alpha_amount,
+                    *alpha_amount,
+                    None,
                 ))
             }
             Some(Call::swap_stake {
@@ -1922,6 +1926,36 @@ where
                     *origin_netuid,
                     *destination_netuid,
                     *alpha_amount,
+                    *alpha_amount,
+                    None,
+                ))
+            }
+            Some(Call::swap_stake_limit {
+                hotkey,
+                origin_netuid,
+                destination_netuid,
+                alpha_amount,
+                limit_price,
+                allow_partial,
+            }) => {
+                // Get the max amount possible to exchange
+                let max_amount = Pallet::<T>::get_max_amount_move(
+                    *origin_netuid,
+                    *destination_netuid,
+                    *limit_price,
+                );
+
+                // Fully validate the user input
+                Self::result_to_validity(Pallet::<T>::validate_stake_transition(
+                    who,
+                    who,
+                    hotkey,
+                    hotkey,
+                    *origin_netuid,
+                    *destination_netuid,
+                    *alpha_amount,
+                    max_amount,
+                    Some(*allow_partial),
                 ))
             }
             Some(Call::register { netuid, .. } | Call::burned_register { netuid, .. }) => {

pallets/subtensor/src/lib.rs

@@ -1769,10 +1769,10 @@ mod dispatches {
         /// 	- The amount of stake to be added to the hotkey staking account.
         ///
         ///  * 'limit_price' (u64):
-        /// 	- The limit price expressed in units of RAO per one Alpha.
+        ///     - The limit price expressed in units of RAO per one Alpha.
         ///
         ///  * 'allow_partial' (bool):
-        /// 	- Allows partial execution of the amount. If set to false, this becomes
+        ///     - Allows partial execution of the amount. If set to false, this becomes
         ///       fill or kill type or order.
         ///
         /// # Event:
@@ -1811,5 +1811,52 @@ mod dispatches {
                 allow_partial,
             )
         }
+
+        /// Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey.
+        ///
+        /// # Arguments
+        /// * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`.
+        /// * `hotkey` - The hotkey whose stake is being swapped.
+        /// * `origin_netuid` - The network/subnet ID from which stake is removed.
+        /// * `destination_netuid` - The network/subnet ID to which stake is added.
+        /// * `alpha_amount` - The amount of stake to swap.
+        /// * `limit_price` - The limit price expressed in units of RAO per one Alpha.
+        /// * `allow_partial` - Allows partial execution of the amount. If set to false, this becomes fill or kill type or order.
+        ///
+        /// # Errors
+        /// Returns an error if:
+        /// * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails).
+        /// * Either `origin_netuid` or `destination_netuid` does not exist.
+        /// * The hotkey does not exist.
+        /// * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`.
+        /// * The swap amount is below the minimum stake requirement.
+        ///
+        /// # Events
+        /// May emit a `StakeSwapped` event on success.
+        #[pallet::call_index(90)]
+        #[pallet::weight((
+            Weight::from_parts(3_000_000, 0).saturating_add(T::DbWeight::get().writes(1)),
+            DispatchClass::Operational,
+            Pays::No
+        ))]
+        pub fn swap_stake_limit(
+            origin: T::RuntimeOrigin,
+            hotkey: T::AccountId,
+            origin_netuid: u16,
+            destination_netuid: u16,
+            alpha_amount: u64,
+            limit_price: u64,
+            allow_partial: bool,
+        ) -> DispatchResult {
+            Self::do_swap_stake_limit(
+                origin,
+                hotkey,
+                origin_netuid,
+                destination_netuid,
+                alpha_amount,
+                limit_price,
+                allow_partial,
+            )
+        }
     }
 }

pallets/subtensor/src/macros/dispatches.rs

@@ -76,7 +76,8 @@ mod hooks {
                 // Migrate to RAO
                 .saturating_add(migrations::migrate_rao::migrate_rao::<T>())
 				// Fix the IsNetworkMember map to be consistent with other storage maps
-				.saturating_add(migrations::migrate_fix_is_network_member::migrate_fix_is_network_member::<T>());
+				.saturating_add(migrations::migrate_fix_is_network_member::migrate_fix_is_network_member::<T>())
+				.saturating_add(migrations::migrate_subnet_volume::migrate_subnet_volume::<T>());
             weight
         }
 

pallets/subtensor/src/macros/hooks.rs

@@ -0,0 +1,33 @@
+use super::*;
+use alloc::string::String;
+use frame_support::{traits::Get, weights::Weight};
+
+pub fn migrate_subnet_volume<T: Config>() -> Weight {
+    let migration_name = b"migrate_subnet_volume".to_vec();
+
+    // Initialize the weight with one read operation.
+    let weight = T::DbWeight::get().reads(1);
+
+    // Check if the migration has already run
+    if HasMigrationRun::<T>::get(&migration_name) {
+        log::info!(
+            "Migration '{:?}' has already run. Skipping.",
+            migration_name
+        );
+        return weight;
+    }
+    log::info!(
+        "Running migration '{}'",
+        String::from_utf8_lossy(&migration_name)
+    );
+
+    let mut migrated = 0u64;
+
+    SubnetVolume::<T>::translate::<u64, _>(|_key, old_value| {
+        migrated = migrated.saturating_add(1);
+        Some(old_value as u128) // Convert and store as u128
+    });
+
+    log::info!("Migrated {} entries in SubnetVolume", migrated);
+    weight.saturating_add(T::DbWeight::get().reads_writes(migrated, migrated))
+}

pallets/subtensor/src/migrations/migrate_subnet_volume.rs

@@ -11,6 +11,7 @@ pub mod migrate_populate_owned_hotkeys;
 pub mod migrate_populate_staking_hotkeys;
 pub mod migrate_rao;
 pub mod migrate_stake_threshold;
+pub mod migrate_subnet_volume;
 pub mod migrate_to_v1_separate_emission;
 pub mod migrate_to_v2_fixed_total_stake;
 pub mod migrate_total_issuance;