use appropriate types (NetUid and TaoCurrency) in sim_swap_tao_for_alpha

Author: gztensor

Cargo.lock

@@ -11,6 +11,7 @@ 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]
@@ -20,5 +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

@@ -11,25 +11,26 @@ 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: u16,
-        tao: u64,
+        netuid: NetUid,
+        tao: TaoCurrency,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
     #[method(name = "swap_simSwapAlphaForTao")]
     fn sim_swap_alpha_for_tao(
         &self,
-        netuid: u16,
-        alpha: u64,
+        netuid: NetUid,
+        alpha: AlphaCurrency,
         at: Option<BlockHash>,
     ) -> RpcResult<Vec<u8>>;
 }
@@ -80,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();
@@ -93,8 +94,8 @@ where
 
     fn sim_swap_tao_for_alpha(
         &self,
-        netuid: u16,
-        tao: u64,
+        netuid: NetUid,
+        tao: TaoCurrency,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -111,8 +112,8 @@ where
 
     fn sim_swap_alpha_for_tao(
         &self,
-        netuid: u16,
-        alpha: u64,
+        netuid: NetUid,
+        alpha: AlphaCurrency,
         at: Option<<Block as BlockT>::Hash>,
     ) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();

pallets/swap/rpc/src/lib.rs

@@ -9,8 +9,9 @@ codec = { workspace = true, features = ["derive"] }
 scale-info.workspace = true
 sp-api.workspace = true
 sp-std.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", "subtensor-swap-interface/std"]
+std = ["codec/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,11 +1,12 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use subtensor_runtime_common::{AlphaCurrency, NetUid, TaoCurrency};
 use subtensor_swap_interface::SwapResult;
 
 sp_api::decl_runtime_apis! {
     pub trait SwapRuntimeApi {
-        fn current_alpha_price(netuid: u16) -> u64;
-        fn sim_swap_tao_for_alpha(netuid: u16, tao: u64) -> SwapResult;
-        fn sim_swap_alpha_for_tao(netuid: u16, alpha: u64) -> SwapResult;
+        fn current_alpha_price(netuid: NetUid) -> u64;
+        fn sim_swap_tao_for_alpha(netuid: NetUid, tao: TaoCurrency) -> SwapResult;
+        fn sim_swap_alpha_for_tao(netuid: NetUid, alpha: AlphaCurrency) -> SwapResult;
     }
 }

pallets/swap/runtime-api/src/lib.rs

@@ -2409,19 +2409,19 @@ 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: u16, tao: u64) -> SwapResult {
+        fn sim_swap_tao_for_alpha(netuid: NetUid, tao: TaoCurrency) -> SwapResult {
             pallet_subtensor_swap::Pallet::<Runtime>::sim_swap(
                 netuid.into(),
                 OrderType::Buy,
-                tao,
+                tao.into(),
             ).unwrap_or(SwapResult {
                 amount_paid_in: 0,
                 amount_paid_out: 0,
@@ -2431,11 +2431,11 @@ impl_runtime_apis! {
             })
         }
 
-        fn sim_swap_alpha_for_tao(netuid: u16, alpha: u64) -> SwapResult {
+        fn sim_swap_alpha_for_tao(netuid: NetUid, alpha: AlphaCurrency) -> SwapResult {
             pallet_subtensor_swap::Pallet::<Runtime>::sim_swap(
                 netuid.into(),
                 OrderType::Sell,
-                alpha,
+                alpha.into(),
             ).unwrap_or(SwapResult {
                 amount_paid_in: 0,
                 amount_paid_out: 0,