refactor: separate runtime api from custom rpc

Cargo.toml

@@ -5,8 +5,7 @@ panic = "unwind"
 members = [
   "nodes/*",
   "pallets/*",
-  "rpc/did/runtime-api",
-  "rpc/public-credentials/runtime-api",
+  "runtime-api/*",
   "runtimes/*",
   "support",
   "crates/*",

pallets/parachain-staking/Cargo.toml

@@ -13,6 +13,8 @@ sp-core = {git = "https://github.com/paritytech/substrate", branch = "polkadot-v
 sp-io = {git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.29"}
 
 [dependencies]
+kilt-runtime-api-staking = {path = "../../runtime-api/staking", default-features = false}
+
 log = "0.4.17"
 parity-scale-codec = {version = "3.1.5", default-features = false, features = ["derive"]}
 scale-info = {version = "2.1.1", default-features = false, features = ["derive", "serde"]}
@@ -40,6 +42,7 @@ runtime-benchmarks = [
 std = [
   "frame-support/std",
   "frame-system/std",
+  "kilt-runtime-api-staking/std",
   "log/std",
   "pallet-authorship/std",
   "pallet-balances/std",

pallets/parachain-staking/src/api.rs

@@ -0,0 +1,87 @@
+// KILT Blockchain – https://botlabs.org
+// Copyright (C) 2019-2022 BOTLabs GmbH
+
+// The KILT Blockchain is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The KILT Blockchain is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// If you feel like getting in touch with us, you can do so at [email protected]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use crate::{
+	types::BalanceOf, CandidatePool, Config, DelegatorState, InflationConfig, Pallet, RewardCount, Rewards,
+	TotalCollatorStake,
+};
+use frame_support::traits::Currency;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	Perquintill,
+};
+
+impl<T: Config> Pallet<T> {
+	/// Calculates the staking rewards for a given account address.
+	///
+	/// At least used in Runtime API.
+	pub fn get_unclaimed_staking_rewards(acc: &T::AccountId) -> BalanceOf<T> {
+		let mut reward_count = RewardCount::<T>::get(acc);
+		let rewards = Rewards::<T>::get(acc);
+
+		// delegators and collators need to be handled differently
+		if let Some(delegator_state) = DelegatorState::<T>::get(acc) {
+			// delegator reward counts do not automatically increment in order to be
+			// scalable, see [increment_delegator_rewards] for details
+			// therefore, we need to query the counter of the collator
+			// (`delegator_stare.owner`)
+			reward_count =
+				reward_count.saturating_add(delegator_state.owner.map(RewardCount::<T>::get).unwrap_or(0u32));
+			let stake = delegator_state.amount;
+			// rewards += stake * (self_count + collator_count) * delegator_reward_rate
+			rewards.saturating_add(Self::calc_block_rewards_delegator(stake, reward_count.into()))
+		} else if Self::is_active_candidate(acc).is_some() {
+			let stake = CandidatePool::<T>::get(acc)
+				.map(|state| state.stake)
+				.unwrap_or_else(BalanceOf::<T>::zero);
+			// rewards += stake * self_count * collator_reward_rate
+			rewards.saturating_add(Self::calc_block_rewards_collator(stake, reward_count.into()))
+		} else {
+			BalanceOf::<T>::zero()
+		}
+	}
+
+	/// Calculates the current staking and reward rates for collators and
+	/// delegators.
+	///
+	/// At least used in Runtime API.
+	pub fn get_staking_rates() -> kilt_runtime_api_staking::StakingRates {
+		let total_issuance = T::Currency::total_issuance();
+		let total_stake = TotalCollatorStake::<T>::get();
+		let inflation_config = InflationConfig::<T>::get();
+		let collator_staking_rate = Perquintill::from_rational(total_stake.collators, total_issuance);
+		let delegator_staking_rate = Perquintill::from_rational(total_stake.delegators, total_issuance);
+		let collator_reward_rate = Perquintill::from_rational(
+			inflation_config.collator.max_rate.deconstruct(),
+			collator_staking_rate.deconstruct(),
+		) * inflation_config.collator.reward_rate.annual;
+		let delegator_reward_rate = Perquintill::from_rational(
+			inflation_config.delegator.max_rate.deconstruct(),
+			delegator_staking_rate.deconstruct(),
+		) * inflation_config.delegator.reward_rate.annual;
+
+		kilt_runtime_api_staking::StakingRates {
+			collator_staking_rate,
+			collator_reward_rate,
+			delegator_staking_rate,
+			delegator_reward_rate,
+		}
+	}
+}