Merge branch 'devnet-ready' into more-storage-query-test

Author: open-junius

Cargo.lock

@@ -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",
 ]

pallets/swap/rpc/Cargo.toml

@@ -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()),
+        }
+    }
 }

pallets/swap/rpc/src/lib.rs

@@ -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"
+]

pallets/swap/runtime-api/Cargo.toml

@@ -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;
     }
 }

pallets/swap/runtime-api/src/lib.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,
+                })
+            }
         }
     }
 

pallets/swap/src/pallet/impls.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(),
+                },
+            )
+        }
     }
 }