Merge pull request #627 from opentensor/fix/remove_childkey_rpcs

chore: remove coldkey swap rpc

Author: distributedstatemachine

node/src/rpc.rs

@@ -60,7 +60,6 @@ where
     C::Api: subtensor_custom_rpc_runtime_api::NeuronInfoRuntimeApi<Block>,
     C::Api: subtensor_custom_rpc_runtime_api::SubnetInfoRuntimeApi<Block>,
     C::Api: subtensor_custom_rpc_runtime_api::SubnetRegistrationRuntimeApi<Block>,
-    C::Api: subtensor_custom_rpc_runtime_api::ColdkeySwapRuntimeApi<Block>,
     B: sc_client_api::Backend<Block> + Send + Sync + 'static,
     P: TransactionPool + 'static,
 {

pallets/subtensor/rpc/src/lib.rs

@@ -12,7 +12,7 @@ use std::sync::Arc;
 use sp_api::ProvideRuntimeApi;
 
 pub use subtensor_custom_rpc_runtime_api::{
-    ColdkeySwapRuntimeApi, DelegateInfoRuntimeApi, NeuronInfoRuntimeApi, SubnetInfoRuntimeApi,
+    DelegateInfoRuntimeApi, NeuronInfoRuntimeApi, SubnetInfoRuntimeApi,
     SubnetRegistrationRuntimeApi,
 };
 
@@ -51,24 +51,6 @@ pub trait SubtensorCustomApi<BlockHash> {
 
     #[method(name = "subnetInfo_getLockCost")]
     fn get_network_lock_cost(&self, at: Option<BlockHash>) -> RpcResult<u64>;
-    #[method(name = "coldkeySwap_getScheduledColdkeySwap")]
-    fn get_scheduled_coldkey_swap(
-        &self,
-        coldkey_account_vec: Vec<u8>,
-        at: Option<BlockHash>,
-    ) -> RpcResult<Vec<u8>>;
-    #[method(name = "coldkeySwap_getRemainingArbitrationPeriod")]
-    fn get_remaining_arbitration_period(
-        &self,
-        coldkey_account_vec: Vec<u8>,
-        at: Option<BlockHash>,
-    ) -> RpcResult<Vec<u8>>;
-    #[method(name = "coldkeySwap_getColdkeySwapDestinations")]
-    fn get_coldkey_swap_destinations(
-        &self,
-        coldkey_account_vec: Vec<u8>,
-        at: Option<BlockHash>,
-    ) -> RpcResult<Vec<u8>>;
 }
 
 pub struct SubtensorCustom<C, P> {
@@ -117,7 +99,6 @@ where
     C::Api: NeuronInfoRuntimeApi<Block>,
     C::Api: SubnetInfoRuntimeApi<Block>,
     C::Api: SubnetRegistrationRuntimeApi<Block>,
-    C::Api: ColdkeySwapRuntimeApi<Block>,
 {
     fn get_delegates(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<Vec<u8>> {
         let api = self.client.runtime_api();
@@ -242,51 +223,4 @@ where
             Error::RuntimeError(format!("Unable to get subnet lock cost: {:?}", e)).into()
         })
     }
-
-    fn get_scheduled_coldkey_swap(
-        &self,
-        coldkey_account_vec: Vec<u8>,
-        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);
-
-        api.get_scheduled_coldkey_swap(at, coldkey_account_vec)
-            .map_err(|e| {
-                Error::RuntimeError(format!("Unable to get scheduled coldkey swap: {:?}", e)).into()
-            })
-    }
-
-    fn get_remaining_arbitration_period(
-        &self,
-        coldkey_account_vec: Vec<u8>,
-        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);
-
-        api.get_remaining_arbitration_period(at, coldkey_account_vec)
-            .map_err(|e| {
-                Error::RuntimeError(format!(
-                    "Unable to get remaining arbitration period: {:?}",
-                    e
-                ))
-                .into()
-            })
-    }
-
-    fn get_coldkey_swap_destinations(
-        &self,
-        coldkey_account_vec: Vec<u8>,
-        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);
-
-        api.get_coldkey_swap_destinations(at, coldkey_account_vec)
-            .map_err(|e| {
-                Error::RuntimeError(format!("Unable to get coldkey swap destinations: {:?}", e))
-                    .into()
-            })
-    }
 }

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

@@ -32,10 +32,4 @@ sp_api::decl_runtime_apis! {
     pub trait SubnetRegistrationRuntimeApi {
         fn get_network_registration_cost() -> u64;
     }
-
-    pub trait ColdkeySwapRuntimeApi {
-        fn get_scheduled_coldkey_swap( coldkey_account_vec: Vec<u8> ) -> Vec<u8>;
-        fn get_remaining_arbitration_period( coldkey_account_vec: Vec<u8> ) -> Vec<u8>;
-        fn get_coldkey_swap_destinations( coldkey_account_vec: Vec<u8> ) -> Vec<u8>;
-    }
 }

pallets/subtensor/src/lib.rs

@@ -51,7 +51,6 @@ mod weights;
 
 pub mod delegate_info;
 pub mod neuron_info;
-pub mod schedule_coldkey_swap_info;
 pub mod stake_info;
 pub mod subnet_info;
 

pallets/subtensor/src/schedule_coldkey_swap_info.rs

@@ -1664,23 +1664,6 @@ impl_runtime_apis! {
             SubtensorModule::get_network_lock_cost()
         }
     }
-
-    impl subtensor_custom_rpc_runtime_api::ColdkeySwapRuntimeApi<Block> for Runtime {
-        fn get_scheduled_coldkey_swap( coldkey_account_vec: Vec<u8> ) -> Vec<u8> {
-            let result = SubtensorModule::get_scheduled_coldkey_swap( coldkey_account_vec );
-            result.encode()
-        }
-
-        fn get_remaining_arbitration_period( coldkey_account_vec: Vec<u8> ) -> Vec<u8> {
-            let result = SubtensorModule::get_remaining_arbitration_period( coldkey_account_vec );
-            result.encode()
-        }
-
-        fn get_coldkey_swap_destinations( coldkey_account_vec: Vec<u8> ) -> Vec<u8> {
-            let result = SubtensorModule::get_coldkey_swap_destinations( coldkey_account_vec );
-            result.encode()
-        }
-    }
 }
 
 // #[cfg(test)]