Update bridges subtree (#1392)

* Move the bridges subtree under root

* Squashed 'bridges/' changes from 277f0d5496..e50398d1c5

e50398d1c5 bridges subtree fixes (#2528)
99af07522d Markdown linter (#1309) (#2526)
733ff0fe7a `polkadot-staging` branch: Use polkadot-sdk dependencies (#2524)
e8a59f141e Fix benchmark with new XCM::V3 `MAX_INSTRUCTIONS_TO_DECODE` (#2514)
62b185de15 Backport `polkadot-sdk` changes to `polkadot-staging` (#2518)
d9658f4d5b Fix equivocation detection containers startup (#2516) (#2517)
d65db28a8f Backport: building images from locally built binaries (#2513)
5fdbaf45f6 Start the equivocation detection loop from the complex relayer (#2507) (#2512)
7fbb67de46 Backport: Implement basic equivocations detection loop (#2375)
cb7efe245c Manually update deps in polkadot staging (#2371)
d17981fc33 #2351 to polkadot-staging (#2359)

git-subtree-dir: bridges
git-subtree-split: e50398d1c594e4e96df70b0bd376e565d17e8558

* Reapply diener workspacify

* Fix Cargo.toml

* Fix test

* Adjustments

bridges/primitives/relayers/src/registration.rs

@@ -0,0 +1,121 @@
+// 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/>.
+
+//! Bridge relayers registration and slashing scheme.
+//!
+//! There is an option to add a refund-relayer signed extension that will compensate
+//! relayer costs of the message delivery and confirmation transactions (as well as
+//! required finality proofs). This extension boosts priority of message delivery
+//! transactions, based on the number of bundled messages. So transaction with more
+//! messages has larger priority than the transaction with less messages.
+//! See `bridge_runtime_common::priority_calculator` for details;
+//!
+//! This encourages relayers to include more messages to their delivery transactions.
+//! At the same time, we are not verifying storage proofs before boosting
+//! priority. Instead, we simply trust relayer, when it says that transaction delivers
+//! `N` messages.
+//!
+//! This allows relayers to submit transactions which declare large number of bundled
+//! transactions to receive priority boost for free, potentially pushing actual delivery
+//! transactions from the block (or even transaction queue). Such transactions are
+//! not free, but their cost is relatively small.
+//!
+//! To alleviate that, we only boost transactions of relayers that have some stake
+//! that guarantees that their transactions are valid. Such relayers get priority
+//! for free, but they risk to lose their stake.
+
+use crate::RewardsAccountParams;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Get, Zero},
+	DispatchError, DispatchResult,
+};
+
+/// Relayer registration.
+#[derive(Copy, Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo, MaxEncodedLen)]
+pub struct Registration<BlockNumber, Balance> {
+	/// The last block number, where this registration is considered active.
+	///
+	/// Relayer has an option to renew his registration (this may be done before it
+	/// is spoiled as well). Starting from block `valid_till + 1`, relayer may `deregister`
+	/// himself and get his stake back.
+	///
+	/// Please keep in mind that priority boost stops working some blocks before the
+	/// registration ends (see [`StakeAndSlash::RequiredRegistrationLease`]).
+	pub valid_till: BlockNumber,
+	/// Active relayer stake, which is mapped to the relayer reserved balance.
+	///
+	/// If `stake` is less than the [`StakeAndSlash::RequiredStake`], the registration
+	/// is considered inactive even if `valid_till + 1` is not yet reached.
+	pub stake: Balance,
+}
+
+/// Relayer stake-and-slash mechanism.
+pub trait StakeAndSlash<AccountId, BlockNumber, Balance> {
+	/// The stake that the relayer must have to have its transactions boosted.
+	type RequiredStake: Get<Balance>;
+	/// Required **remaining** registration lease to be able to get transaction priority boost.
+	///
+	/// If the difference between registration's `valid_till` and the current block number
+	/// is less than the `RequiredRegistrationLease`, it becomes inactive and relayer transaction
+	/// won't get priority boost. This period exists, because priority is calculated when
+	/// transaction is placed to the queue (and it is reevaluated periodically) and then some time
+	/// may pass before transaction will be included into the block.
+	type RequiredRegistrationLease: Get<BlockNumber>;
+
+	/// Reserve the given amount at relayer account.
+	fn reserve(relayer: &AccountId, amount: Balance) -> DispatchResult;
+	/// `Unreserve` the given amount from relayer account.
+	///
+	/// Returns amount that we have failed to `unreserve`.
+	fn unreserve(relayer: &AccountId, amount: Balance) -> Balance;
+	/// Slash up to `amount` from reserved balance of account `relayer` and send funds to given
+	/// `beneficiary`.
+	///
+	/// Returns `Ok(_)` with non-zero balance if we have failed to repatriate some portion of stake.
+	fn repatriate_reserved(
+		relayer: &AccountId,
+		beneficiary: RewardsAccountParams,
+		amount: Balance,
+	) -> Result<Balance, DispatchError>;
+}
+
+impl<AccountId, BlockNumber, Balance> StakeAndSlash<AccountId, BlockNumber, Balance> for ()
+where
+	Balance: Default + Zero,
+	BlockNumber: Default,
+{
+	type RequiredStake = ();
+	type RequiredRegistrationLease = ();
+
+	fn reserve(_relayer: &AccountId, _amount: Balance) -> DispatchResult {
+		Ok(())
+	}
+
+	fn unreserve(_relayer: &AccountId, _amount: Balance) -> Balance {
+		Zero::zero()
+	}
+
+	fn repatriate_reserved(
+		_relayer: &AccountId,
+		_beneficiary: RewardsAccountParams,
+		_amount: Balance,
+	) -> Result<Balance, DispatchError> {
+		Ok(Zero::zero())
+	}
+}