change: ETCM-12419 decouple sidechain-rpc from slots (#1095)

Author: AmbientTea

Cargo.lock

@@ -34,12 +34,18 @@ supported by the toolkit, this change is backwards compatible for existing chain
 and instead uses `CommitteeMember` and `AuthoritySelectionInputs` types directly, which were moved from
 `authority_selection_inherents` crate to `sp_session_validator_management`.
 As these types were the only ones supported by the toolkit, this change is backwards compatible for existing chains.
+* `pallet-sidechain-rpc` by default no longer provides information about sidechain slots and uses the newly added
+runtime APIs `sp_sidechain::GetEpochDurationApi` instead of deprecated `sp_sidechain::SlotApi`. Chain builders should
+implement the new API in their runtime. Backward compatibility option can be switched on by enabling `legacy-slotapi-compat`
+feature in the crate, which will cause legacy chain nodes to still use `SlotApi` where present and include the
+`sidechain.slot` as an optional field.
 
 ## Removed
 
 * `pallet-partner-chains-session` has been removed. Partner Chains should use only the stock Substrate session pallet
 * `PalletSessionSupport` type provided by `pallet-session-validator-management`. The `SessionManager` and `ShouldEndSession`
   implementations were moved directly to the `Pallet` type instead.
+* `sidechain.slots` field in the response of `sidechain_getStatus` RPC method
 
 ## Fixed
 
@@ -53,6 +59,7 @@ types using Substrate's `app_crypto` macro. This should be a drop-in replacement
 for the analogous cross-chain key types that previously had to be defined by each
 Partner Chain separately for use in `pallet_session_validator_management` and
 other pallets that use cross-chain keys.
+* `sp_sidechain::GetEpochDurationApi` runtime API
 
 # v1.8.0
 

changelog.md

@@ -56,7 +56,7 @@ sp-block-production-log = { workspace = true }
 sidechain-domain = { workspace = true }
 sidechain-slots = { workspace = true }
 sp-sidechain = { workspace = true }
-pallet-sidechain-rpc = { workspace = true }
+pallet-sidechain-rpc = { workspace = true, features = ["legacy-slotapi-compat"] }
 pallet-session-validator-management = { workspace = true }
 sp-session-validator-management = { workspace = true }
 sp-session-validator-management-query = { workspace = true }

demo/node/Cargo.toml

@@ -25,10 +25,11 @@ use sc_rpc::SubscriptionTaskExecutor;
 use sc_transaction_pool_api::TransactionPool;
 use sidechain_domain::ScEpochNumber;
 use sidechain_domain::mainchain_epoch::MainchainEpochConfig;
-use sp_api::ProvideRuntimeApi;
+use sp_api::{CallApiAt, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
 use sp_session_validator_management_query::SessionValidatorManagementQuery;
+use sp_sidechain::GetEpochDurationApi;
 use std::sync::Arc;
 use time_source::TimeSource;
 
@@ -66,6 +67,7 @@ pub fn create_full<C, P, B, T>(
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
 	C: ProvideRuntimeApi<Block>,
+	C: CallApiAt<Block>,
 	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError> + 'static,
 	C: Send + Sync + 'static,
 	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
@@ -84,6 +86,7 @@ where
 			ScEpochNumber,
 		>,
 	C::Api: CandidateValidationApi<Block>,
+	C::Api: GetEpochDurationApi<Block>,
 	P: TransactionPool + 'static,
 	B: sc_client_api::Backend<Block> + Send + Sync + 'static,
 	B::State: sc_client_api::backend::StateBackend<sp_runtime::traits::HashingFor<Block>>,

demo/node/src/rpc.rs

@@ -1063,6 +1063,12 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl sp_sidechain::GetEpochDurationApi<Block> for Runtime {
+		fn get_epoch_duration_millis() -> u64 {
+			u64::from(Sidechain::slots_per_epoch().0) * MILLISECS_PER_BLOCK
+		}
+	}
+
 	impl sidechain_slots::SlotApi<Block> for Runtime {
 		fn slot_config() -> sidechain_slots::ScSlotConfig {
 			sidechain_slots::ScSlotConfig {

demo/runtime/src/lib.rs

@@ -32,7 +32,6 @@ def test_get_status(self, api: BlockchainApi):
         assert partner_chain_status['mainchain']['nextEpochTimestamp']
         assert partner_chain_status['sidechain']['nextEpochTimestamp']
         assert partner_chain_status['sidechain']['epoch']
-        assert partner_chain_status['sidechain']['slot']
 
     @mark.test_key('ETCM-7442')
     def test_get_params(self, api: BlockchainApi):

e2e-tests/tests/test_rpc.py

@@ -64,6 +64,12 @@ mod api_declarations {
 			fn genesis_utxo() -> UtxoId;
 		}
 
+		/// Runtime API for retrieving the Partner Chain's epoch duration
+		pub trait GetEpochDurationApi {
+			/// Returns Partner Chain epoch duration in milliseconds
+			fn get_epoch_duration_millis() -> u64;
+		}
+
 		/// Runtime API for getting information about current Partner Chain slot and epoch
 		#[deprecated(since = "1.7.0", note = "Code that needs this data should define its own runtime API instead.")]
 		pub trait GetSidechainStatus {

toolkit/sidechain/primitives/src/lib.rs

@@ -23,7 +23,6 @@ sp-api = { workspace = true, features = ['std'] }
 sp-blockchain = { workspace = true }
 sp-sidechain = { workspace = true, features = ['std'] }
 sidechain-domain = { workspace = true, features = ['std'] }
-sidechain-slots = { workspace = true, features = ['std', 'serde'] }
 serde_json = { workspace = true, features = ['std'] }
 sp-timestamp = { workspace = true, features = ['std'] }
 hex = { workspace = true, features = ['std'] }
@@ -35,7 +34,7 @@ derive-new = { workspace = true }
 serde_json = { workspace = true }
 pretty_assertions = { workspace = true }
 time-source = { workspace = true, features = ['mock'] }
-sp-consensus-slots = { workspace = true, features = ["std"] }
 
 [features]
 default = []
+legacy-slotapi-compat = []

toolkit/sidechain/rpc/Cargo.toml

@@ -0,0 +1,44 @@
+//! Backward compatibility support for legacy features and APIs
+
+/// Support for legacy chains that used to implement `sidechain_slots::SlotApi`
+pub(crate) mod slots {
+	use parity_scale_codec::Decode;
+	use sp_api::{CallApiAt, CallApiAtParams};
+	use sp_runtime::traits::Block as BlockT;
+
+	/// Raw method name of `sidechain_slots::SlotApi::slot_config`
+	const RAW_GET_SLOT_RUNTIME_METHOD: &str = "SlotApi_slot_config";
+
+	/// Slot configuration type
+	#[derive(sp_core::Decode, Debug)]
+	pub(crate) struct ScSlotConfig {
+		pub(crate) slots_per_epoch: u32,
+		pub(crate) slot_duration_millis: u64,
+	}
+
+	/// Trait to read slot config using `sidechain_slots::SlotApi`, failing gracefully if it's not available
+	pub(crate) trait GetScSlotConfig<Block: BlockT> {
+		fn get_sc_slot_config(&self, best_block: Block::Hash) -> Option<ScSlotConfig>;
+	}
+
+	impl<Client, Block> GetScSlotConfig<Block> for Client
+	where
+		Block: BlockT,
+		Client: CallApiAt<Block> + Send + Sync + 'static,
+	{
+		fn get_sc_slot_config(&self, best_block: Block::Hash) -> Option<ScSlotConfig> {
+			let call_params = CallApiAtParams {
+				at: best_block,
+				function: RAW_GET_SLOT_RUNTIME_METHOD,
+				arguments: vec![],
+				overlayed_changes: &Default::default(),
+				call_context: sp_api::CallContext::Offchain,
+				recorder: &None,
+				extensions: &Default::default(),
+			};
+			let raw_result = self.call_api_at(call_params).ok()?;
+			let slot_config = ScSlotConfig::decode(&mut &raw_result[..]).ok()?;
+			Some(slot_config)
+		}
+	}
+}

toolkit/sidechain/rpc/src/legacy_compat.rs

@@ -4,22 +4,20 @@
 //!
 //! ## Implementing runtime APIs
 //!
-//! Your runtime should implement the [SlotApi] and [GetGenesisUtxo] runtime APIs. For example, if
-//! your chain uses Aura for consensus, they may be implemented similar to this:
+//! Your runtime should implement the [GetGenesisUtxo] and [GetEpochDurationApi] runtime APIs.
+//! For example, if your chain uses Aura for consensus, they may be implemented similar to this:
 //! ```rust,ignore
-//! impl sidechain_slots::SlotApi<Block> for Runtime {
-//!    fn slot_config() -> sidechain_slots::ScSlotConfig {
-//!      sidechain_slots::ScSlotConfig {
-//!        slots_per_epoch: Sidechain::slots_per_epoch(),
-//!        slot_duration: SlotDuration::from(Aura::slot_duration())
-//!      }
-//!    }
-//!  }
 //! impl sp_sidechain::GetGenesisUtxo<Block> for Runtime {
 //!   fn genesis_utxo() -> UtxoId {
 //!     Sidechain::genesis_utxo()
 //!   }
 //! }
+//!
+//! impl sp_sidechain::GetEpochDurationApi<Block> for Runtime {
+//! 	fn get_epoch_duration_millis() -> u64 {
+//! 		BLOCKS_PER_EPOCH * MILLISECS_PER_BLOCK
+//! 	}
+//! }
 //! ```
 //!
 //! ## Adding to the RPC stack
@@ -30,10 +28,9 @@
 //! # use jsonrpsee::RpcModule;
 //! # use pallet_sidechain_rpc::{*, types::GetBestHash};
 //! # use sidechain_domain::mainchain_epoch::MainchainEpochConfig;
-//! # use sidechain_slots::SlotApi;
-//! # use sp_api::ProvideRuntimeApi;
+//! # use sp_api::{ CallApiAt, ProvideRuntimeApi };
 //! # use sp_runtime::traits::Block as BlockT;
-//! # use sp_sidechain::GetGenesisUtxo;
+//! # use sp_sidechain::{ GetEpochDurationApi, GetGenesisUtxo };
 //! # use std::sync::Arc;
 //! # use time_source::TimeSource;
 //! fn create_rpc<B: BlockT, C: Send + Sync + 'static>(
@@ -42,8 +39,8 @@
 //!    data_source: Arc<dyn SidechainRpcDataSource + Send + Sync>,
 //! ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 //! where
-//!     C: ProvideRuntimeApi<B> + GetBestHash<B>,
-//!     C::Api: SlotApi<B> + GetGenesisUtxo<B>
+//!     C: ProvideRuntimeApi<B> + GetBestHash<B> + CallApiAt<B>,
+//!     C::Api: GetGenesisUtxo<B> + GetEpochDurationApi<B>
 //! {
 //!
 //!     let mut module = RpcModule::new(());
@@ -66,29 +63,42 @@
 //! data source is provided by the Partner Chain toolkit in the `partner_chains_db_sync_data_sources`
 //! crate.
 //!
+//! ## Legacy compatibility mode
+//!
+//! In previous versions of the Partner Chains toolkit, the RPC services in this crate relied on now
+//! deprecated runtime api `sp_sidechain::SlotApi` to compute Partner Chain epochs and current slot.
+//! For Partner Chains that started before this dependency was removed, a compatibility mode is
+//! provided behind the `legacy-slotapi-compat` feature flag. Enabling this flag will cause the nodes to
+//! use this runtime API when present and optionally include information about current Patner Chain
+//! slot in `sidechain.slot` field of `sidechain_getStatus` response.
+//!
 //! [GetGenesisUtxo]: sp_sidechain::GetGenesisUtxo
-//! [SlotApi]: sidechain_slots::SlotApi
+//! [GetEpochDurationApi]: sp_sidechain::GetEpochDurationApi
 #![deny(missing_docs)]
 use derive_new::new;
 use jsonrpsee::{
 	core::{RpcResult, async_trait},
 	proc_macros::rpc,
 	types::{ErrorObject, ErrorObjectOwned, error::ErrorCode},
 };
+#[cfg(feature = "legacy-slotapi-compat")]
+use legacy_compat::slots::*;
 use sidechain_domain::mainchain_epoch::{MainchainEpochConfig, MainchainEpochDerivation};
 use sidechain_domain::{MainchainBlock, UtxoId};
-use sidechain_slots::SlotApi;
 use sp_api::ProvideRuntimeApi;
-use sp_core::offchain::Timestamp;
+use sp_core::offchain::{Duration, Timestamp};
 use sp_runtime::traits::Block as BlockT;
-use sp_sidechain::GetGenesisUtxo;
+use sp_sidechain::{GetEpochDurationApi, GetGenesisUtxo};
 use std::sync::Arc;
 use time_source::*;
 use types::*;
 
 /// Response types returned by RPC endpoints for Sidechain pallet
 pub mod types;
 
+#[cfg(feature = "legacy-slotapi-compat")]
+mod legacy_compat;
+
 #[cfg(test)]
 mod tests;
 
@@ -142,37 +152,89 @@ impl<C, B> SidechainRpc<C, B> {
 	}
 }
 
+/// Runtime client that can serve data to sidechain RPC
+trait SidechainRpcClient<Block: BlockT> {
+	/// Returns Partner Chain epoch duration
+	fn get_epoch_duration(
+		&self,
+		best_block: Block::Hash,
+	) -> Result<Duration, Box<dyn std::error::Error + Send + Sync>>;
+
+	/// Returns the Partner Chain's genesis UTXO
+	fn get_genesis_utxo(
+		&self,
+		best_block: Block::Hash,
+	) -> Result<UtxoId, Box<dyn std::error::Error + Send + Sync>>;
+
+	#[cfg(feature = "legacy-slotapi-compat")]
+	/// Returns slot duration
+	fn get_maybe_slot_duration(&self, best_block: Block::Hash) -> Option<u64>;
+}
+
+impl<Block, Client> SidechainRpcClient<Block> for Client
+where
+	Block: BlockT,
+	Client: sp_api::CallApiAt<Block> + Send + Sync + 'static,
+	Client: ProvideRuntimeApi<Block>,
+	Client::Api: GetEpochDurationApi<Block>,
+	Client::Api: GetGenesisUtxo<Block>,
+{
+	fn get_epoch_duration(
+		&self,
+		best_block: Block::Hash,
+	) -> Result<Duration, Box<dyn std::error::Error + Send + Sync>> {
+		#[cfg(feature = "legacy-slotapi-compat")]
+		if let Some(slot_config) = self.get_sc_slot_config(best_block) {
+			return Ok(Duration::from_millis(
+				u64::from(slot_config.slots_per_epoch) * slot_config.slot_duration_millis,
+			));
+		}
+
+		Ok(Duration::from_millis(self.runtime_api().get_epoch_duration_millis(best_block)?))
+	}
+
+	fn get_genesis_utxo(
+		&self,
+		best_block: Block::Hash,
+	) -> Result<UtxoId, Box<dyn std::error::Error + Send + Sync>> {
+		Ok(self.runtime_api().genesis_utxo(best_block)?)
+	}
+
+	#[cfg(feature = "legacy-slotapi-compat")]
+	fn get_maybe_slot_duration(&self, best_block: Block::Hash) -> Option<u64> {
+		let slot_config = self.get_sc_slot_config(best_block)?;
+		Some(slot_config.slot_duration_millis)
+	}
+}
+
 #[async_trait]
 impl<C, Block> SidechainRpcApiServer for SidechainRpc<C, Block>
 where
 	Block: BlockT,
 	C: Send + Sync + 'static,
-	C: ProvideRuntimeApi<Block>,
+	C: SidechainRpcClient<Block>,
 	C: GetBestHash<Block>,
-	C::Api: SlotApi<Block> + GetGenesisUtxo<Block>,
 {
 	fn get_params(&self) -> RpcResult<GetParamsOutput> {
-		let api = self.client.runtime_api();
 		let best_block = self.client.best_hash();
 
-		let genesis_utxo = api.genesis_utxo(best_block).map_err(error_object_from)?;
+		let genesis_utxo = self.client.get_genesis_utxo(best_block).map_err(error_object_from)?;
 
 		Ok(GetParamsOutput { genesis_utxo })
 	}
 
 	async fn get_status(&self) -> RpcResult<GetStatusResponse> {
-		let api = self.client.runtime_api();
 		let best_block = self.client.best_hash();
 
-		let slot_config = api.slot_config(best_block).map_err(error_object_from)?;
-
 		let current_timestamp = self.get_current_timestamp();
-		let current_sidechain_slot =
-			slot_config.slot_from_timestamp(current_timestamp.unix_millis());
-		let current_sidechain_epoch = slot_config.epoch_number(current_sidechain_slot);
-		let next_sidechain_epoch_timestamp = slot_config
-			.epoch_start_time(current_sidechain_epoch.next())
-			.ok_or(GetStatusRpcError::CannotConvertSidechainSlotToTimestamp)?;
+
+		let sc_epoch_duration: Duration =
+			self.client.get_epoch_duration(best_block).map_err(error_object_from)?;
+
+		let current_sidechain_epoch = current_timestamp.unix_millis() / sc_epoch_duration.millis();
+
+		let next_sidechain_epoch_timestamp =
+			Timestamp::from((current_sidechain_epoch + 1) * sc_epoch_duration.millis());
 
 		let latest_mainchain_block =
 			self.data_source.get_latest_block_info().await.map_err(|err| {
@@ -188,8 +250,10 @@ where
 
 		Ok(GetStatusResponse {
 			sidechain: SidechainData {
-				epoch: current_sidechain_epoch.0,
-				slot: current_sidechain_slot.into(),
+				epoch: current_sidechain_epoch,
+				#[cfg(feature = "legacy-slotapi-compat")]
+				slot: (self.client.get_maybe_slot_duration(best_block))
+					.map(|duration| current_timestamp.unix_millis() / duration),
 				next_epoch_timestamp: next_sidechain_epoch_timestamp,
 			},
 			mainchain: MainchainData {