merge target

open-junius · open-junius · commit ef5f1a708e98 · 2025-08-19T14:52:39.000+08:00
diff --git a/.github/workflows/run-benchmarks.yml b/.github/workflows/run-benchmarks.yml
@@ -16,7 +16,7 @@ concurrency:
 
 jobs:
   validate-benchmarks:
-    runs-on: [self-hosted, type-ccx33]
+    runs-on: Benchmarking
 
     env:
       SKIP_BENCHMARKS: "0"
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
diff --git a/pallets/commitments/src/lib.rs b/pallets/commitments/src/lib.rs
@@ -205,7 +205,7 @@ pub mod pallet {
         /// Set the commitment for a given netuid
         #[pallet::call_index(0)]
         #[pallet::weight((
-            Weight::from_parts(25_070_000, 0)
+            Weight::from_parts(33_480_000, 0)
 			.saturating_add(T::DbWeight::get().reads(5_u64))
 			.saturating_add(T::DbWeight::get().writes(4_u64)),
             DispatchClass::Operational,
@@ -343,7 +343,7 @@ pub mod pallet {
         /// Sudo-set MaxSpace
         #[pallet::call_index(2)]
         #[pallet::weight((
-            Weight::from_parts(1_660_000, 0)
+            Weight::from_parts(2_856_000, 0)
 			.saturating_add(T::DbWeight::get().reads(0_u64))
 			.saturating_add(T::DbWeight::get().writes(1_u64)),
             DispatchClass::Operational,
diff --git a/pallets/drand/src/lib.rs b/pallets/drand/src/lib.rs
@@ -404,7 +404,7 @@ pub mod pallet {
         /// * `origin`: the root user
         /// * `config`: the beacon configuration
         #[pallet::call_index(1)]
-        #[pallet::weight(Weight::from_parts(5_450_000, 0)
+        #[pallet::weight(Weight::from_parts(8_766_000, 0)
         .saturating_add(T::DbWeight::get().reads(0_u64))
         .saturating_add(T::DbWeight::get().writes(2_u64)))]
         pub fn set_beacon_config(
@@ -425,7 +425,7 @@ pub mod pallet {
 
         /// allows the root user to set the oldest stored round
         #[pallet::call_index(2)]
-        #[pallet::weight(Weight::from_parts(3_350_000, 0)
+        #[pallet::weight(Weight::from_parts(5_370_000, 0)
         .saturating_add(T::DbWeight::get().reads(0_u64))
         .saturating_add(T::DbWeight::get().writes(1_u64)))]
         pub fn set_oldest_stored_round(origin: OriginFor<T>, oldest_round: u64) -> DispatchResult {
diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs
diff --git a/pallets/subtensor/src/tests/registration.rs b/pallets/subtensor/src/tests/registration.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
 use approx::assert_abs_diff_eq;
-use frame_support::dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays};
+use frame_support::dispatch::DispatchInfo;
 use frame_support::sp_runtime::{DispatchError, transaction_validity::TransactionSource};
 use frame_support::traits::Currency;
 use frame_support::{assert_err, assert_noop, assert_ok};
@@ -18,36 +18,6 @@ use crate::{AxonInfoOf, CustomTransactionError, Error, SubtensorTransactionExten
     subscribing::subscribe() tests
 *********************************************/
 
-// Tests a basic registration dispatch passes.
-#[test]
-fn test_registration_subscribe_ok_dispatch_info_ok() {
-    new_test_ext(1).execute_with(|| {
-        let block_number: u64 = 0;
-        let nonce: u64 = 0;
-        let netuid = NetUid::from(1);
-        let work: Vec<u8> = vec![0; 32];
-        let hotkey: U256 = U256::from(0);
-        let coldkey: U256 = U256::from(0);
-        let call = RuntimeCall::SubtensorModule(SubtensorCall::register {
-            netuid,
-            block_number,
-            nonce,
-            work,
-            hotkey,
-            coldkey,
-        });
-        assert_eq!(
-            call.get_dispatch_info(),
-            DispatchInfo {
-                call_weight: frame_support::weights::Weight::from_parts(3_111_800_000, 0),
-                extension_weight: frame_support::weights::Weight::zero(),
-                class: DispatchClass::Normal,
-                pays_fee: Pays::No
-            }
-        );
-    });
-}
-
 #[test]
 fn test_registration_difficulty() {
     new_test_ext(1).execute_with(|| {
diff --git a/pallets/swap/rpc/Cargo.toml b/pallets/swap/rpc/Cargo.toml
@@ -11,6 +11,8 @@ sp-api.workspace = true
 sp-blockchain.workspace = true
 sp-runtime.workspace = true
 pallet-subtensor-swap-runtime-api.workspace = true
+subtensor-runtime-common = { workspace = true, default-features = false }
+subtensor-swap-interface.workspace = true
 
 [features]
 default = ["std"]
@@ -19,4 +21,6 @@ std = [
 	"pallet-subtensor-swap-runtime-api/std",
 	"sp-api/std",
 	"sp-runtime/std",
+	"subtensor-runtime-common/std",
+	"subtensor-swap-interface/std",
 ]
diff --git a/pallets/swap/rpc/src/lib.rs b/pallets/swap/rpc/src/lib.rs
@@ -1,5 +1,6 @@
 //! RPC interface for the Swap pallet
 
+use codec::Encode;
 use std::sync::Arc;
 
 use jsonrpsee::{
@@ -10,13 +11,28 @@ use jsonrpsee::{
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_runtime::traits::Block as BlockT;
+use subtensor_runtime_common::{AlphaCurrency, NetUid, TaoCurrency};
 
 pub use pallet_subtensor_swap_runtime_api::SwapRuntimeApi;
 
 #[rpc(client, server)]
 pub trait SwapRpcApi<BlockHash> {
     #[method(name = "swap_currentAlphaPrice")]
-    fn current_alpha_price(&self, netuid: u16, at: Option<BlockHash>) -> RpcResult<u64>;
+    fn current_alpha_price(&self, netuid: NetUid, at: Option<BlockHash>) -> RpcResult<u64>;
+    #[method(name = "swap_simSwapTaoForAlpha")]
+    fn sim_swap_tao_for_alpha(
+        &self,
+        netuid: NetUid,
+        tao: TaoCurrency,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<u8>>;
+    #[method(name = "swap_simSwapAlphaForTao")]
+    fn sim_swap_alpha_for_tao(
+        &self,
+        netuid: NetUid,
+        alpha: AlphaCurrency,
+        at: Option<BlockHash>,
+    ) -> RpcResult<Vec<u8>>;
 }
 
 /// Error type of this RPC api.
@@ -65,7 +81,7 @@ where
 {
     fn current_alpha_price(
         &self,
-        netuid: u16,
+        netuid: NetUid,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<u64> {
         let api = self.client.runtime_api();
@@ -75,4 +91,40 @@ where
             Error::RuntimeError(format!("Unable to get current alpha price: {e:?}")).into()
         })
     }
+
+    fn sim_swap_tao_for_alpha(
+        &self,
+        netuid: NetUid,
+        tao: TaoCurrency,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.sim_swap_tao_for_alpha(at, netuid, tao) {
+            Ok(result) => Ok(result.encode()),
+            Err(e) => Err(Error::RuntimeError(format!(
+                "Unable to simulate tao -> alpha swap: {e:?}"
+            ))
+            .into()),
+        }
+    }
+
+    fn sim_swap_alpha_for_tao(
+        &self,
+        netuid: NetUid,
+        alpha: AlphaCurrency,
+        at: Option<<Block as BlockT>::Hash>,
+    ) -> RpcResult<Vec<u8>> {
+        let api = self.client.runtime_api();
+        let at = at.unwrap_or_else(|| self.client.info().best_hash);
+
+        match api.sim_swap_alpha_for_tao(at, netuid, alpha) {
+            Ok(result) => Ok(result.encode()),
+            Err(e) => Err(Error::RuntimeError(format!(
+                "Unable to simulate alpha -> tao swap: {e:?}"
+            ))
+            .into()),
+        }
+    }
 }
diff --git a/pallets/swap/runtime-api/Cargo.toml b/pallets/swap/runtime-api/Cargo.toml
@@ -6,10 +6,22 @@ edition.workspace = true
 
 [dependencies]
 codec = { workspace = true, features = ["derive"] }
+frame-support.workspace = true
 scale-info.workspace = true
 sp-api.workspace = true
 sp-std.workspace = true
+subtensor-macros.workspace = true
+subtensor-runtime-common = { workspace = true, default-features = false }
+subtensor-swap-interface.workspace = true
 
 [features]
 default = ["std"]
-std = ["codec/std", "scale-info/std", "sp-api/std", "sp-std/std"]
+std = [
+    "codec/std",
+    "frame-support/std",
+    "scale-info/std",
+    "sp-api/std",
+    "sp-std/std",
+    "subtensor-runtime-common/std",
+    "subtensor-swap-interface/std"
+]
diff --git a/pallets/swap/runtime-api/src/lib.rs b/pallets/swap/runtime-api/src/lib.rs
@@ -1,7 +1,22 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use frame_support::pallet_prelude::*;
+use subtensor_macros::freeze_struct;
+use subtensor_runtime_common::{AlphaCurrency, NetUid, TaoCurrency};
+
+#[freeze_struct("3a4fd213b5de5eb6")]
+#[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
+pub struct SimSwapResult {
+    pub tao_amount: TaoCurrency,
+    pub alpha_amount: AlphaCurrency,
+    pub tao_fee: TaoCurrency,
+    pub alpha_fee: AlphaCurrency,
+}
+
 sp_api::decl_runtime_apis! {
     pub trait SwapRuntimeApi {
-        fn current_alpha_price(netuid: u16) -> u64;
+        fn current_alpha_price(netuid: NetUid) -> u64;
+        fn sim_swap_tao_for_alpha(netuid: NetUid, tao: TaoCurrency) -> SimSwapResult;
+        fn sim_swap_alpha_for_tao(netuid: NetUid, alpha: AlphaCurrency) -> SimSwapResult;
     }
 }
diff --git a/pallets/swap/src/pallet/impls.rs b/pallets/swap/src/pallet/impls.rs
@@ -1253,13 +1253,20 @@ impl<T: Config> SwapHandler<T::AccountId> for Pallet<T> {
 
                 Self::swap(netuid, order_t, amount, price_limit, false, true)
             }
-            _ => Ok(SwapResult {
-                amount_paid_in: amount,
-                amount_paid_out: amount,
-                fee_paid: 0,
-                tao_reserve_delta: 0,
-                alpha_reserve_delta: 0,
-            }),
+            _ => {
+                let actual_amount = if T::SubnetInfo::exists(netuid) {
+                    amount
+                } else {
+                    0
+                };
+                Ok(SwapResult {
+                    amount_paid_in: actual_amount,
+                    amount_paid_out: actual_amount,
+                    fee_paid: 0,
+                    tao_reserve_delta: 0,
+                    alpha_reserve_delta: 0,
+                })
+            }
         }
     }
 
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
@@ -36,6 +36,7 @@ use pallet_subtensor::rpc_info::{
     stake_info::StakeInfo,
     subnet_info::{SubnetHyperparams, SubnetHyperparamsV2, SubnetInfo, SubnetInfov2},
 };
+use pallet_subtensor_swap_runtime_api::SimSwapResult;
 use runtime_common::prod_or_fast;
 use sp_api::impl_runtime_apis;
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
@@ -62,6 +63,7 @@ use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;
 use subtensor_precompiles::Precompiles;
 use subtensor_runtime_common::{AlphaCurrency, TaoCurrency, time::*, *};
+use subtensor_swap_interface::{OrderType, SwapHandler};
 
 // A few exports that help ease life for downstream crates.
 pub use frame_support::{
@@ -2408,13 +2410,57 @@ impl_runtime_apis! {
     }
 
     impl pallet_subtensor_swap_runtime_api::SwapRuntimeApi<Block> for Runtime {
-        fn current_alpha_price(netuid: u16) -> u64 {
+        fn current_alpha_price(netuid: NetUid) -> u64 {
             use substrate_fixed::types::U96F32;
 
             pallet_subtensor_swap::Pallet::<Runtime>::current_price(netuid.into())
                 .saturating_mul(U96F32::from_num(1_000_000_000))
                 .saturating_to_num()
         }
+
+        fn sim_swap_tao_for_alpha(netuid: NetUid, tao: TaoCurrency) -> SimSwapResult {
+            pallet_subtensor_swap::Pallet::<Runtime>::sim_swap(
+                netuid.into(),
+                OrderType::Buy,
+                tao.into(),
+            )
+            .map_or_else(
+                |_| SimSwapResult {
+                    tao_amount:   0.into(),
+                    alpha_amount: 0.into(),
+                    tao_fee:      0.into(),
+                    alpha_fee:    0.into(),
+                },
+                |sr| SimSwapResult {
+                    tao_amount:   sr.amount_paid_in.into(),
+                    alpha_amount: sr.amount_paid_out.into(),
+                    tao_fee:      sr.fee_paid.into(),
+                    alpha_fee:    0.into(),
+                },
+            )
+        }
+
+        fn sim_swap_alpha_for_tao(netuid: NetUid, alpha: AlphaCurrency) -> SimSwapResult {
+            pallet_subtensor_swap::Pallet::<Runtime>::sim_swap(
+                netuid.into(),
+                OrderType::Sell,
+                alpha.into(),
+            )
+            .map_or_else(
+                |_| SimSwapResult {
+                    tao_amount:   0.into(),
+                    alpha_amount: 0.into(),
+                    tao_fee:      0.into(),
+                    alpha_fee:    0.into(),
+                },
+                |sr| SimSwapResult {
+                    tao_amount:   sr.amount_paid_out.into(),
+                    alpha_amount: sr.amount_paid_in.into(),
+                    tao_fee:      0.into(),
+                    alpha_fee:    sr.fee_paid.into(),
+                },
+            )
+        }
     }
 }
 
