357 lines
11 KiB
Rust
357 lines
11 KiB
Rust
// Copyright (C) Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Bridges Common.
|
|
|
|
// Parity Bridges Common 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.
|
|
|
|
// Parity Bridges Common 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 Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! Primitives of messages module.
|
|
|
|
#![warn(missing_docs)]
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
pub use extension::{
|
|
BatchCallUnpacker, ExtensionCallData, ExtensionCallInfo, ExtensionConfig,
|
|
RuntimeWithUtilityPallet,
|
|
};
|
|
pub use registration::{ExplicitOrAccountParams, Registration, StakeAndSlash};
|
|
|
|
use pezbp_runtime::{ChainId, StorageDoubleMapKeyProvider};
|
|
use pezframe_support::{traits::tokens::Preservation, Blake2_128Concat, Identity};
|
|
use pezsp_runtime::{
|
|
codec::{Codec, Decode, DecodeWithMemTracking, Encode, EncodeLike, MaxEncodedLen},
|
|
traits::AccountIdConversion,
|
|
TypeId,
|
|
};
|
|
use pezsp_std::{fmt::Debug, marker::PhantomData};
|
|
use scale_info::TypeInfo;
|
|
|
|
mod extension;
|
|
mod registration;
|
|
|
|
/// The owner of the sovereign account that should pay the rewards.
|
|
///
|
|
/// Each of the 2 final points connected by a bridge owns a sovereign account at each end of the
|
|
/// bridge. So here, at this end of the bridge there can be 2 sovereign accounts that pay rewards.
|
|
#[derive(
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Decode,
|
|
DecodeWithMemTracking,
|
|
Encode,
|
|
Eq,
|
|
PartialEq,
|
|
TypeInfo,
|
|
MaxEncodedLen,
|
|
)]
|
|
pub enum RewardsAccountOwner {
|
|
/// The sovereign account of the final chain on this end of the bridge.
|
|
ThisChain,
|
|
/// The sovereign account of the final chain on the other end of the bridge.
|
|
BridgedChain,
|
|
}
|
|
|
|
/// Structure used to identify the account that pays a reward to the relayer.
|
|
///
|
|
/// A bridge connects 2 bridge ends. Each one is located on a separate relay chain. The bridge ends
|
|
/// can be the final destinations of the bridge, or they can be intermediary points
|
|
/// (e.g. a bridge hub) used to forward messages between pairs of teyrchains on the bridged relay
|
|
/// chains. A pair of such teyrchains is connected using a bridge lane. Each of the 2 final
|
|
/// destinations of a bridge lane must have a sovereign account at each end of the bridge and each
|
|
/// of the sovereign accounts will pay rewards for different operations. So we need multiple
|
|
/// parameters to identify the account that pays a reward to the relayer.
|
|
#[derive(
|
|
Copy,
|
|
Clone,
|
|
Debug,
|
|
Decode,
|
|
DecodeWithMemTracking,
|
|
Encode,
|
|
Eq,
|
|
PartialEq,
|
|
TypeInfo,
|
|
MaxEncodedLen,
|
|
)]
|
|
pub struct RewardsAccountParams<LaneId> {
|
|
// **IMPORTANT NOTE**: the order of fields here matters - we are using
|
|
// `into_account_truncating` and lane id is already `32` byte, so if other fields are encoded
|
|
// after it, they're simply dropped. So lane id shall be the last field.
|
|
owner: RewardsAccountOwner,
|
|
bridged_chain_id: ChainId,
|
|
lane_id: LaneId,
|
|
}
|
|
|
|
impl<LaneId: Decode + Encode> RewardsAccountParams<LaneId> {
|
|
/// Create a new instance of `RewardsAccountParams`.
|
|
pub const fn new(
|
|
lane_id: LaneId,
|
|
bridged_chain_id: ChainId,
|
|
owner: RewardsAccountOwner,
|
|
) -> Self {
|
|
Self { lane_id, bridged_chain_id, owner }
|
|
}
|
|
|
|
/// Getter for `lane_id`.
|
|
pub const fn lane_id(&self) -> &LaneId {
|
|
&self.lane_id
|
|
}
|
|
}
|
|
|
|
impl<LaneId: Decode + Encode> TypeId for RewardsAccountParams<LaneId> {
|
|
const TYPE_ID: [u8; 4] = *b"brap";
|
|
}
|
|
|
|
/// Reward payment procedure.
|
|
pub trait PaymentProcedure<Relayer, Reward, RewardBalance> {
|
|
/// Error that may be returned by the procedure.
|
|
type Error: Debug;
|
|
|
|
/// Type parameter used to identify the beneficiaries eligible to receive rewards.
|
|
type Beneficiary: Clone + Debug + Decode + Encode + Eq + TypeInfo;
|
|
|
|
/// Pay reward to the relayer (or alternative beneficiary if provided) from the account with
|
|
/// provided params.
|
|
fn pay_reward(
|
|
relayer: &Relayer,
|
|
reward: Reward,
|
|
reward_balance: RewardBalance,
|
|
beneficiary: Self::Beneficiary,
|
|
) -> Result<(), Self::Error>;
|
|
}
|
|
|
|
impl<Relayer, Reward, RewardBalance> PaymentProcedure<Relayer, Reward, RewardBalance> for () {
|
|
type Error = &'static str;
|
|
type Beneficiary = ();
|
|
|
|
fn pay_reward(
|
|
_: &Relayer,
|
|
_: Reward,
|
|
_: RewardBalance,
|
|
_: Self::Beneficiary,
|
|
) -> Result<(), Self::Error> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Reward payment procedure that executes a `balances::transfer` call from the account
|
|
/// derived from the given `RewardsAccountParams` to the relayer or an alternative beneficiary.
|
|
pub struct PayRewardFromAccount<T, Relayer, LaneId, RewardBalance>(
|
|
PhantomData<(T, Relayer, LaneId, RewardBalance)>,
|
|
);
|
|
|
|
impl<T, Relayer, LaneId, RewardBalance> PayRewardFromAccount<T, Relayer, LaneId, RewardBalance>
|
|
where
|
|
Relayer: Decode + Encode,
|
|
LaneId: Decode + Encode,
|
|
{
|
|
/// Return account that pays rewards based on the provided parameters.
|
|
pub fn rewards_account(params: RewardsAccountParams<LaneId>) -> Relayer {
|
|
params.into_sub_account_truncating(b"rewards-account")
|
|
}
|
|
}
|
|
|
|
impl<T, Relayer, LaneId, RewardBalance>
|
|
PaymentProcedure<Relayer, RewardsAccountParams<LaneId>, RewardBalance>
|
|
for PayRewardFromAccount<T, Relayer, LaneId, RewardBalance>
|
|
where
|
|
T: pezframe_support::traits::fungible::Mutate<Relayer>,
|
|
T::Balance: From<RewardBalance>,
|
|
Relayer: Clone + Debug + Decode + Encode + Eq + TypeInfo,
|
|
LaneId: Decode + Encode,
|
|
{
|
|
type Error = pezsp_runtime::DispatchError;
|
|
type Beneficiary = Relayer;
|
|
|
|
fn pay_reward(
|
|
_: &Relayer,
|
|
reward_kind: RewardsAccountParams<LaneId>,
|
|
reward: RewardBalance,
|
|
beneficiary: Self::Beneficiary,
|
|
) -> Result<(), Self::Error> {
|
|
T::transfer(
|
|
&Self::rewards_account(reward_kind),
|
|
&beneficiary.into(),
|
|
reward.into(),
|
|
Preservation::Expendable,
|
|
)
|
|
.map(drop)
|
|
}
|
|
}
|
|
|
|
/// Can be used to access the runtime storage key within the `RelayerRewards` map of the relayers
|
|
/// pezpallet.
|
|
pub struct RelayerRewardsKeyProvider<AccountId, Reward, RewardBalance>(
|
|
PhantomData<(AccountId, Reward, RewardBalance)>,
|
|
);
|
|
|
|
impl<AccountId, Reward, RewardBalance> StorageDoubleMapKeyProvider
|
|
for RelayerRewardsKeyProvider<AccountId, Reward, RewardBalance>
|
|
where
|
|
AccountId: 'static + Codec + EncodeLike + Send + Sync,
|
|
Reward: Codec + EncodeLike + Send + Sync,
|
|
RewardBalance: 'static + Codec + EncodeLike + Send + Sync,
|
|
{
|
|
const MAP_NAME: &'static str = "RelayerRewards";
|
|
|
|
type Hasher1 = Blake2_128Concat;
|
|
type Key1 = AccountId;
|
|
type Hasher2 = Identity;
|
|
type Key2 = Reward;
|
|
type Value = RewardBalance;
|
|
}
|
|
|
|
/// A trait defining a reward ledger, which tracks rewards that can be later claimed.
|
|
///
|
|
/// This ledger allows registering rewards for a relayer, categorized by a specific `Reward`.
|
|
/// The registered rewards can be claimed later through an appropriate payment procedure.
|
|
pub trait RewardLedger<Relayer, Reward, RewardBalance> {
|
|
/// Registers a reward for a given relayer.
|
|
fn register_reward(relayer: &Relayer, reward: Reward, reward_balance: RewardBalance);
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use bp_messages::{HashedLaneId, LaneIdType, LegacyLaneId};
|
|
use pezsp_runtime::{app_crypto::Ss58Codec, testing::H256};
|
|
|
|
#[test]
|
|
fn different_lanes_are_using_different_accounts() {
|
|
assert_eq!(
|
|
PayRewardFromAccount::<(), H256, HashedLaneId, ()>::rewards_account(
|
|
RewardsAccountParams::new(
|
|
HashedLaneId::try_new(1, 2).unwrap(),
|
|
*b"test",
|
|
RewardsAccountOwner::ThisChain
|
|
)
|
|
),
|
|
hex_literal::hex!("627261700074657374b1d3dccd8b3c3a012afe265f3e3c4432129b8aee50c9dc")
|
|
.into(),
|
|
);
|
|
|
|
assert_eq!(
|
|
PayRewardFromAccount::<(), H256, HashedLaneId, ()>::rewards_account(
|
|
RewardsAccountParams::new(
|
|
HashedLaneId::try_new(1, 3).unwrap(),
|
|
*b"test",
|
|
RewardsAccountOwner::ThisChain
|
|
)
|
|
),
|
|
hex_literal::hex!("627261700074657374a43e8951aa302c133beb5f85821a21645f07b487270ef3")
|
|
.into(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn different_directions_are_using_different_accounts() {
|
|
assert_eq!(
|
|
PayRewardFromAccount::<(), H256, HashedLaneId, ()>::rewards_account(
|
|
RewardsAccountParams::new(
|
|
HashedLaneId::try_new(1, 2).unwrap(),
|
|
*b"test",
|
|
RewardsAccountOwner::ThisChain
|
|
)
|
|
),
|
|
hex_literal::hex!("627261700074657374b1d3dccd8b3c3a012afe265f3e3c4432129b8aee50c9dc")
|
|
.into(),
|
|
);
|
|
|
|
assert_eq!(
|
|
PayRewardFromAccount::<(), H256, HashedLaneId, ()>::rewards_account(
|
|
RewardsAccountParams::new(
|
|
HashedLaneId::try_new(1, 2).unwrap(),
|
|
*b"test",
|
|
RewardsAccountOwner::BridgedChain
|
|
)
|
|
),
|
|
hex_literal::hex!("627261700174657374b1d3dccd8b3c3a012afe265f3e3c4432129b8aee50c9dc")
|
|
.into(),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn pay_reward_from_account_for_legacy_lane_id_works() {
|
|
let test_data = vec![
|
|
// Note: these accounts are used for integration tests within
|
|
// `bridges_pezkuwichain_zagros.sh`
|
|
(
|
|
LegacyLaneId([0, 0, 0, 1]),
|
|
b"bhks",
|
|
RewardsAccountOwner::ThisChain,
|
|
(0_u16, "13E5fui97x6KTwNnSjaEKZ8s7kJNot5F3aUsy3jUtuoMyUec"),
|
|
),
|
|
(
|
|
LegacyLaneId([0, 0, 0, 1]),
|
|
b"bhks",
|
|
RewardsAccountOwner::BridgedChain,
|
|
(0_u16, "13E5fui9Ka9Vz4JbGN3xWjmwDNxnxF1N9Hhhbeu3VCqLChuj"),
|
|
),
|
|
(
|
|
LegacyLaneId([0, 0, 0, 1]),
|
|
b"bhpd",
|
|
RewardsAccountOwner::ThisChain,
|
|
(2_u16, "EoQBtnwtXqnSnr9cgBEJpKU7NjeC9EnR4D1VjgcvHz9ZYmS"),
|
|
),
|
|
(
|
|
LegacyLaneId([0, 0, 0, 1]),
|
|
b"bhpd",
|
|
RewardsAccountOwner::BridgedChain,
|
|
(2_u16, "EoQBtnx69txxumxSJexVzxYD1Q4LWAuWmRq8LrBWb27nhYN"),
|
|
),
|
|
// Note: these accounts are used for integration tests within
|
|
// `bridges_pezkuwi_kusama.sh` from fellows.
|
|
(
|
|
LegacyLaneId([0, 0, 0, 2]),
|
|
b"bhwd",
|
|
RewardsAccountOwner::ThisChain,
|
|
(4_u16, "SNihsskf7bFhnHH9HJFMjWD3FJ96ESdAQTFZUAtXudRQbaH"),
|
|
),
|
|
(
|
|
LegacyLaneId([0, 0, 0, 2]),
|
|
b"bhwd",
|
|
RewardsAccountOwner::BridgedChain,
|
|
(4_u16, "SNihsskrjeSDuD5xumyYv9H8sxZEbNkG7g5C5LT8CfPdaSE"),
|
|
),
|
|
(
|
|
LegacyLaneId([0, 0, 0, 2]),
|
|
b"bhro",
|
|
RewardsAccountOwner::ThisChain,
|
|
(4_u16, "SNihsskf7bF2vWogkC6uFoiqPhd3dUX6TGzYZ1ocJdo3xHp"),
|
|
),
|
|
(
|
|
LegacyLaneId([0, 0, 0, 2]),
|
|
b"bhro",
|
|
RewardsAccountOwner::BridgedChain,
|
|
(4_u16, "SNihsskrjeRZ3ScWNfq6SSnw2N3BzQeCAVpBABNCbfmHENB"),
|
|
),
|
|
];
|
|
|
|
for (lane_id, bridged_chain_id, owner, (expected_ss58, expected_account)) in test_data {
|
|
assert_eq!(
|
|
expected_account,
|
|
pezsp_runtime::AccountId32::new(PayRewardFromAccount::<
|
|
[u8; 32],
|
|
[u8; 32],
|
|
LegacyLaneId,
|
|
(),
|
|
>::rewards_account(RewardsAccountParams::new(
|
|
lane_id,
|
|
*bridged_chain_id,
|
|
owner
|
|
)))
|
|
.to_ss58check_with_version(expected_ss58.into())
|
|
);
|
|
}
|
|
}
|
|
}
|