#![warn(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)]
pub use registration::{Registration, StakeAndSlash};
use bp_messages::LaneId;
use bp_runtime::{ChainId, StorageDoubleMapKeyProvider};
use frame_support::{traits::tokens::Preservation, Blake2_128Concat, Identity};
use scale_info::TypeInfo;
use sp_runtime::{
codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen},
traits::AccountIdConversion,
TypeId,
};
use sp_std::{fmt::Debug, marker::PhantomData};
mod registration;
#[derive(Copy, Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo, MaxEncodedLen)]
pub enum RewardsAccountOwner {
ThisChain,
BridgedChain,
}
#[derive(Copy, Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo, MaxEncodedLen)]
pub struct RewardsAccountParams {
lane_id: LaneId,
bridged_chain_id: ChainId,
owner: RewardsAccountOwner,
}
impl RewardsAccountParams {
pub const fn new(
lane_id: LaneId,
bridged_chain_id: ChainId,
owner: RewardsAccountOwner,
) -> Self {
Self { lane_id, bridged_chain_id, owner }
}
}
impl TypeId for RewardsAccountParams {
const TYPE_ID: [u8; 4] = *b"brap";
}
pub trait PaymentProcedure<Relayer, Reward> {
type Error: Debug;
fn pay_reward(
relayer: &Relayer,
rewards_account_params: RewardsAccountParams,
reward: Reward,
) -> Result<(), Self::Error>;
}
impl<Relayer, Reward> PaymentProcedure<Relayer, Reward> for () {
type Error = &'static str;
fn pay_reward(_: &Relayer, _: RewardsAccountParams, _: Reward) -> Result<(), Self::Error> {
Ok(())
}
}
pub struct PayRewardFromAccount<T, Relayer>(PhantomData<(T, Relayer)>);
impl<T, Relayer> PayRewardFromAccount<T, Relayer>
where
Relayer: Decode + Encode,
{
pub fn rewards_account(params: RewardsAccountParams) -> Relayer {
params.into_sub_account_truncating(b"rewards-account")
}
}
impl<T, Relayer> PaymentProcedure<Relayer, T::Balance> for PayRewardFromAccount<T, Relayer>
where
T: frame_support::traits::fungible::Mutate<Relayer>,
Relayer: Decode + Encode,
{
type Error = sp_runtime::DispatchError;
fn pay_reward(
relayer: &Relayer,
rewards_account_params: RewardsAccountParams,
reward: T::Balance,
) -> Result<(), Self::Error> {
T::transfer(
&Self::rewards_account(rewards_account_params),
relayer,
reward,
Preservation::Expendable,
)
.map(drop)
}
}
pub struct RelayerRewardsKeyProvider<AccountId, Reward>(PhantomData<(AccountId, Reward)>);
impl<AccountId, Reward> StorageDoubleMapKeyProvider for RelayerRewardsKeyProvider<AccountId, Reward>
where
AccountId: Codec + EncodeLike,
Reward: Codec + EncodeLike,
{
const MAP_NAME: &'static str = "RelayerRewards";
type Hasher1 = Blake2_128Concat;
type Key1 = AccountId;
type Hasher2 = Identity;
type Key2 = RewardsAccountParams;
type Value = Reward;
}
#[cfg(test)]
mod tests {
use super::*;
use bp_messages::LaneId;
use sp_runtime::testing::H256;
#[test]
fn different_lanes_are_using_different_accounts() {
assert_eq!(
PayRewardFromAccount::<(), H256>::rewards_account(RewardsAccountParams::new(
LaneId([0, 0, 0, 0]),
*b"test",
RewardsAccountOwner::ThisChain
)),
hex_literal::hex!("62726170000000007465737400726577617264732d6163636f756e7400000000")
.into(),
);
assert_eq!(
PayRewardFromAccount::<(), H256>::rewards_account(RewardsAccountParams::new(
LaneId([0, 0, 0, 1]),
*b"test",
RewardsAccountOwner::ThisChain
)),
hex_literal::hex!("62726170000000017465737400726577617264732d6163636f756e7400000000")
.into(),
);
}
#[test]
fn different_directions_are_using_different_accounts() {
assert_eq!(
PayRewardFromAccount::<(), H256>::rewards_account(RewardsAccountParams::new(
LaneId([0, 0, 0, 0]),
*b"test",
RewardsAccountOwner::ThisChain
)),
hex_literal::hex!("62726170000000007465737400726577617264732d6163636f756e7400000000")
.into(),
);
assert_eq!(
PayRewardFromAccount::<(), H256>::rewards_account(RewardsAccountParams::new(
LaneId([0, 0, 0, 0]),
*b"test",
RewardsAccountOwner::BridgedChain
)),
hex_literal::hex!("62726170000000007465737401726577617264732d6163636f756e7400000000")
.into(),
);
}
}