Polkadot <> Kusama relayers (#1122)

* relay headers between Kusama and Polkadot * relay messages between Kusama and Polkadot * complex Kusama <> Polkadot relayer * expose relayer_fund_account_id from messages pallet * create relayers fund accounts on Kusama/Polkadot + some more fixes * fmt * fix compilation * compilation + clippy * compilation * MAXIMAL_BALANCE_DECREASE_PER_DAY for K<>P header relays * fmt * deduplicate tests * Update modules/messages/src/lib.rs Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com> * extract storage_parameter_key function * other grumbles * fix * fmt Co-authored-by: Tomasz Drwięga <tomusdrw@users.noreply.github.com>
2026-05-30 14:01:02 +00:00 · 2021-09-21 16:53:37 +03:00
parent 417903f9e7
commit 2db84b74cc
31 changed files with 1936 additions and 68 deletions
@@ -6,9 +6,24 @@ edition = "2018"
 license = "GPL-3.0-or-later WITH Classpath-exception-2.0"

 [dependencies]
+codec = { package = "parity-scale-codec", version = "2.2.0" }
 relay-substrate-client = { path = "../client-substrate" }
 relay-utils = { path = "../utils" }

 # Bridge dependencies

+bp-header-chain = { path = "../../primitives/header-chain" }
+bp-kusama = { path = "../../primitives/chain-kusama" }
+bp-message-dispatch = { path = "../../primitives/message-dispatch" }
+bp-messages = { path = "../../primitives/messages" }
 bp-polkadot = { path = "../../primitives/chain-polkadot" }
+bp-polkadot-core = { path = "../../primitives/polkadot-core" }
+bp-runtime = { path = "../../primitives/runtime" }
+bridge-runtime-common = { path = "../../bin/runtime-common" }
+pallet-bridge-dispatch = { path = "../../modules/dispatch" }
+
+# Substrate Dependencies
+
+frame-support = { git = "https://github.com/paritytech/substrate", branch = "master" }
+sp-core = { git = "https://github.com/paritytech/substrate", branch = "master" }
+sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }
@@ -16,9 +16,16 @@

 //! Types used to connect to the Polkadot chain.

-use relay_substrate_client::{Chain, ChainBase};
+use codec::Encode;
+use relay_substrate_client::{
+	Chain, ChainBase, ChainWithBalances, TransactionEraOf, TransactionSignScheme, UnsignedTransaction,
+};
+use sp_core::{storage::StorageKey, Pair};
+use sp_runtime::{generic::SignedPayload, traits::IdentifyAccount};
 use std::time::Duration;

+pub mod runtime;
+
 /// Polkadot header id.
 pub type HeaderId = relay_utils::HeaderId<bp_polkadot::Hash, bp_polkadot::BlockNumber>;

@@ -45,9 +52,68 @@ impl Chain for Polkadot {
 	const MAXIMAL_ENCODED_ACCOUNT_ID_SIZE: u32 = bp_polkadot::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE;

 	type SignedBlock = bp_polkadot::SignedBlock;
-	type Call = ();
+	type Call = crate::runtime::Call;
 	type WeightToFee = bp_polkadot::WeightToFee;
 }

+impl ChainWithBalances for Polkadot {
+	fn account_info_storage_key(account_id: &Self::AccountId) -> StorageKey {
+		StorageKey(bp_polkadot::account_info_storage_key(account_id))
+	}
+}
+
+impl TransactionSignScheme for Polkadot {
+	type Chain = Polkadot;
+	type AccountKeyPair = sp_core::sr25519::Pair;
+	type SignedTransaction = crate::runtime::UncheckedExtrinsic;
+
+	fn sign_transaction(
+		genesis_hash: <Self::Chain as ChainBase>::Hash,
+		signer: &Self::AccountKeyPair,
+		era: TransactionEraOf<Self::Chain>,
+		unsigned: UnsignedTransaction<Self::Chain>,
+	) -> Self::SignedTransaction {
+		let raw_payload = SignedPayload::new(
+			unsigned.call,
+			bp_polkadot::SignedExtensions::new(bp_polkadot::VERSION, era, genesis_hash, unsigned.nonce, unsigned.tip),
+		)
+		.expect("SignedExtension never fails.");
+
+		let signature = raw_payload.using_encoded(|payload| signer.sign(payload));
+		let signer: sp_runtime::MultiSigner = signer.public().into();
+		let (call, extra, _) = raw_payload.deconstruct();
+
+		bp_polkadot::UncheckedExtrinsic::new_signed(
+			call,
+			sp_runtime::MultiAddress::Id(signer.into_account()),
+			signature.into(),
+			extra,
+		)
+	}
+
+	fn is_signed(tx: &Self::SignedTransaction) -> bool {
+		tx.signature.is_some()
+	}
+
+	fn is_signed_by(signer: &Self::AccountKeyPair, tx: &Self::SignedTransaction) -> bool {
+		tx.signature
+			.as_ref()
+			.map(|(address, _, _)| *address == bp_polkadot::AccountId::from(*signer.public().as_array_ref()).into())
+			.unwrap_or(false)
+	}
+
+	fn parse_transaction(tx: Self::SignedTransaction) -> Option<UnsignedTransaction<Self::Chain>> {
+		let extra = &tx.signature.as_ref()?.2;
+		Some(UnsignedTransaction {
+			call: tx.function,
+			nonce: extra.nonce(),
+			tip: extra.tip(),
+		})
+	}
+}
+
 /// Polkadot header type used in headers sync.
 pub type SyncHeader = relay_substrate_client::SyncHeader<bp_polkadot::Header>;
+
+/// Polkadot signing params.
+pub type SigningParams = sp_core::sr25519::Pair;
@@ -0,0 +1,151 @@
+// Copyright 2019-2021 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/>.
+
+//! Types that are specific to the Polkadot runtime.
+
+use bp_messages::{LaneId, UnrewardedRelayersState};
+use bp_polkadot_core::{AccountAddress, Balance, PolkadotLike};
+use bp_runtime::Chain;
+use codec::{Compact, Decode, Encode};
+use frame_support::weights::Weight;
+use sp_runtime::FixedU128;
+
+/// Unchecked Polkadot extrinsic.
+pub type UncheckedExtrinsic = bp_polkadot_core::UncheckedExtrinsic<Call>;
+
+/// Kusama account ownership digest from Polkadot.
+///
+/// The byte vector returned by this function should be signed with a Kusama account private key.
+/// This way, the owner of `kusam_account_id` on Polkadot proves that the Kusama account private key
+/// is also under his control.
+pub fn polkadot_to_kusama_account_ownership_digest<Call, AccountId, SpecVersion>(
+	kusama_call: &Call,
+	kusam_account_id: AccountId,
+	kusama_spec_version: SpecVersion,
+) -> Vec<u8>
+where
+	Call: codec::Encode,
+	AccountId: codec::Encode,
+	SpecVersion: codec::Encode,
+{
+	pallet_bridge_dispatch::account_ownership_digest(
+		kusama_call,
+		kusam_account_id,
+		kusama_spec_version,
+		bp_runtime::POLKADOT_CHAIN_ID,
+		bp_runtime::KUSAMA_CHAIN_ID,
+	)
+}
+
+/// Polkadot Runtime `Call` enum.
+///
+/// The enum represents a subset of possible `Call`s we can send to Polkadot chain.
+/// Ideally this code would be auto-generated from metadata, because we want to
+/// avoid depending directly on the ENTIRE runtime just to get the encoding of `Dispatchable`s.
+///
+/// All entries here (like pretty much in the entire file) must be kept in sync with Polkadot
+/// `construct_runtime`, so that we maintain SCALE-compatibility.
+///
+/// See: [link](https://github.com/paritytech/kusama/blob/master/runtime/kusam/src/lib.rs)
+#[allow(clippy::large_enum_variant)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+pub enum Call {
+	/// System pallet.
+	#[codec(index = 0)]
+	System(SystemCall),
+	/// Balances pallet.
+	#[codec(index = 5)]
+	Balances(BalancesCall),
+	/// Kusama bridge pallet.
+	#[codec(index = 110)]
+	BridgeKusamaGrandpa(BridgeKusamaGrandpaCall),
+	/// Kusama messages pallet.
+	#[codec(index = 111)]
+	BridgeKusamaMessages(BridgeKusamaMessagesCall),
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[allow(non_camel_case_types)]
+pub enum SystemCall {
+	#[codec(index = 1)]
+	remark(Vec<u8>),
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[allow(non_camel_case_types)]
+pub enum BalancesCall {
+	#[codec(index = 0)]
+	transfer(AccountAddress, Compact<Balance>),
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[allow(non_camel_case_types)]
+pub enum BridgeKusamaGrandpaCall {
+	#[codec(index = 0)]
+	submit_finality_proof(
+		<PolkadotLike as Chain>::Header,
+		bp_header_chain::justification::GrandpaJustification<<PolkadotLike as Chain>::Header>,
+	),
+	#[codec(index = 1)]
+	initialize(bp_header_chain::InitializationData<<PolkadotLike as Chain>::Header>),
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[allow(non_camel_case_types)]
+pub enum BridgeKusamaMessagesCall {
+	#[codec(index = 2)]
+	update_pallet_parameter(BridgeKusamaMessagesParameter),
+	#[codec(index = 3)]
+	send_message(
+		LaneId,
+		bp_message_dispatch::MessagePayload<
+			bp_polkadot::AccountId,
+			bp_kusama::AccountId,
+			bp_kusama::AccountPublic,
+			Vec<u8>,
+		>,
+		bp_polkadot::Balance,
+	),
+	#[codec(index = 5)]
+	receive_messages_proof(
+		bp_kusama::AccountId,
+		bridge_runtime_common::messages::target::FromBridgedChainMessagesProof<bp_kusama::Hash>,
+		u32,
+		Weight,
+	),
+	#[codec(index = 6)]
+	receive_messages_delivery_proof(
+		bridge_runtime_common::messages::source::FromBridgedChainMessagesDeliveryProof<bp_kusama::Hash>,
+		UnrewardedRelayersState,
+	),
+}
+
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
+pub enum BridgeKusamaMessagesParameter {
+	#[codec(index = 0)]
+	KusamaToPolkadotConversionRate(FixedU128),
+}
+
+impl sp_runtime::traits::Dispatchable for Call {
+	type Origin = ();
+	type Config = ();
+	type Info = ();
+	type PostInfo = ();
+
+	fn dispatch(self, _origin: Self::Origin) -> sp_runtime::DispatchResultWithInfo<Self::PostInfo> {
+		unimplemented!("The Call is not expected to be dispatched.")
+	}
+}