Register-parachain subcommand of substrate-relay (#1170)

* register parachain relay subcommand

* revert cargo patch

* added basic test

* fmt

bridges/relays/bin-substrate/Cargo.toml

@@ -28,6 +28,7 @@ bp-message-dispatch = { path = "../../primitives/message-dispatch" }
 bp-millau = { path = "../../primitives/chain-millau" }
 bp-polkadot = { path = "../../primitives/chain-polkadot" }
 bp-rialto = { path = "../../primitives/chain-rialto" }
+bp-rialto-parachain = { path = "../../primitives/chain-rialto-parachain" }
 bp-rococo = { path = "../../primitives/chain-rococo" }
 bp-token-swap = { path = "../../primitives/token-swap" }
 bp-wococo = { path = "../../primitives/chain-wococo" }
@@ -44,11 +45,13 @@ relay-kusama-client = { path = "../client-kusama" }
 relay-millau-client = { path = "../client-millau" }
 relay-polkadot-client = { path = "../client-polkadot" }
 relay-rialto-client = { path = "../client-rialto" }
+relay-rialto-parachain-client = { path = "../client-rialto-parachain" }
 relay-rococo-client = { path = "../client-rococo" }
 relay-wococo-client = { path = "../client-wococo" }
 relay-substrate-client = { path = "../client-substrate" }
 relay-utils = { path = "../utils" }
 relay-westend-client = { path = "../client-westend" }
+rialto-parachain-runtime = { path = "../../bin/rialto-parachain/runtime" }
 rialto-runtime = { path = "../../bin/rialto/runtime" }
 substrate-relay-helper = { path = "../lib-substrate-relay" }
 
@@ -61,6 +64,13 @@ sp-io = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-runtime = { git = "https://github.com/paritytech/substrate", branch = "master" }
 sp-version = { git = "https://github.com/paritytech/substrate", branch = "master" }
 
+# Polkadot Dependencies
+
+polkadot-parachain = { git = "https://github.com/paritytech/polkadot", branch = "master" }
+polkadot-primitives = { git = "https://github.com/paritytech/polkadot", branch = "master" }
+polkadot-runtime-common = { git = "https://github.com/paritytech/polkadot", branch = "master" }
+polkadot-runtime-parachains = { git = "https://github.com/paritytech/polkadot", branch = "master" }
+
 [dev-dependencies]
 hex-literal = "0.3"
 pallet-bridge-grandpa = { path = "../../modules/grandpa" }

bridges/relays/bin-substrate/src/chains/mod.rs

@@ -34,6 +34,7 @@ mod kusama;
 mod millau;
 mod polkadot;
 mod rialto;
+mod rialto_parachain;
 mod rococo;
 mod westend;
 mod wococo;

bridges/relays/bin-substrate/src/chains/rialto_parachain.rs

@@ -0,0 +1,82 @@
+// 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/>.
+
+//! Rialto parachain specification for CLI.
+
+use crate::cli::{
+	encode_call::{Call, CliEncodeCall},
+	encode_message, CliChain,
+};
+use bp_message_dispatch::MessagePayload;
+use codec::Decode;
+use frame_support::weights::{DispatchInfo, GetDispatchInfo, Weight};
+use relay_rialto_parachain_client::RialtoParachain;
+use sp_version::RuntimeVersion;
+
+impl CliEncodeCall for RialtoParachain {
+	fn max_extrinsic_size() -> u32 {
+		bp_rialto_parachain::max_extrinsic_size()
+	}
+
+	fn encode_call(call: &Call) -> anyhow::Result<Self::Call> {
+		Ok(match call {
+			Call::Raw { data } => Decode::decode(&mut &*data.0)?,
+			Call::Remark { remark_payload, .. } => rialto_parachain_runtime::Call::System(
+				rialto_parachain_runtime::SystemCall::remark(
+					remark_payload.as_ref().map(|x| x.0.clone()).unwrap_or_default(),
+				),
+			),
+			Call::Transfer { recipient, amount } => rialto_parachain_runtime::Call::Balances(
+				rialto_parachain_runtime::BalancesCall::transfer(
+					recipient.raw_id().into(),
+					amount.0,
+				),
+			),
+			Call::BridgeSendMessage { .. } =>
+				anyhow::bail!("Bridge messages are not (yet) supported here",),
+		})
+	}
+
+	fn get_dispatch_info(call: &rialto_parachain_runtime::Call) -> anyhow::Result<DispatchInfo> {
+		Ok(call.get_dispatch_info())
+	}
+}
+
+impl CliChain for RialtoParachain {
+	const RUNTIME_VERSION: RuntimeVersion = rialto_parachain_runtime::VERSION;
+
+	type KeyPair = sp_core::sr25519::Pair;
+	type MessagePayload = MessagePayload<
+		bp_rialto_parachain::AccountId,
+		bp_millau::AccountSigner,
+		bp_millau::Signature,
+		Vec<u8>,
+	>;
+
+	fn ss58_format() -> u16 {
+		rialto_parachain_runtime::SS58Prefix::get() as u16
+	}
+
+	fn max_extrinsic_weight() -> Weight {
+		bp_rialto_parachain::max_extrinsic_weight()
+	}
+
+	fn encode_message(
+		_message: encode_message::MessagePayload,
+	) -> Result<Self::MessagePayload, String> {
+		Err("Not supported".into())
+	}
+}

bridges/relays/bin-substrate/src/cli/mod.rs

@@ -32,6 +32,7 @@ pub(crate) mod send_message;
 
 mod derive_account;
 mod init_bridge;
+mod register_parachain;
 mod relay_headers;
 mod relay_headers_and_messages;
 mod relay_messages;
@@ -93,6 +94,8 @@ pub enum Command {
 	ResubmitTransactions(resubmit_transactions::ResubmitTransactions),
 	/// Swap tokens using token-swap bridge.
 	SwapTokens(swap_tokens::SwapTokens),
+	/// Register parachain.
+	RegisterParachain(register_parachain::RegisterParachain),
 }
 
 impl Command {
@@ -128,6 +131,7 @@ impl Command {
 			Self::DeriveAccount(arg) => arg.run().await?,
 			Self::ResubmitTransactions(arg) => arg.run().await?,
 			Self::SwapTokens(arg) => arg.run().await?,
+			Self::RegisterParachain(arg) => arg.run().await?,
 		}
 		Ok(())
 	}
@@ -438,6 +442,7 @@ macro_rules! declare_chain_options {
 				}
 
 				/// Parse signing params into chain-specific KeyPair.
+				#[allow(dead_code)]
 				pub fn to_keypair<Chain: CliChain>(&self) -> anyhow::Result<Chain::KeyPair> {
 					let suri = match (self.[<$chain_prefix _signer>].as_ref(), self.[<$chain_prefix _signer_file>].as_ref()) {
 						(Some(suri), _) => suri.to_owned(),
@@ -515,6 +520,8 @@ macro_rules! declare_chain_options {
 
 declare_chain_options!(Source, source);
 declare_chain_options!(Target, target);
+declare_chain_options!(Relaychain, relaychain);
+declare_chain_options!(Parachain, parachain);
 
 #[cfg(test)]
 mod tests {

bridges/relays/bin-substrate/src/cli/register_parachain.rs

@@ -0,0 +1,343 @@
+// 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/>.
+
+use crate::cli::{
+	swap_tokens::wait_until_transaction_is_finalized, Balance, ParachainConnectionParams,
+	RelaychainConnectionParams, RelaychainSigningParams,
+};
+
+use codec::Encode;
+use num_traits::Zero;
+use polkadot_parachain::primitives::{
+	HeadData as ParaHeadData, Id as ParaId, ValidationCode as ParaValidationCode,
+};
+use polkadot_runtime_common::{
+	paras_registrar::Call as ParaRegistrarCall, slots::Call as ParaSlotsCall,
+};
+use polkadot_runtime_parachains::paras::ParaLifecycle;
+use relay_substrate_client::{
+	AccountIdOf, CallOf, Chain, Client, TransactionSignScheme, UnsignedTransaction,
+};
+use rialto_runtime::SudoCall;
+use sp_core::{
+	storage::{well_known_keys::CODE, StorageKey},
+	Bytes, Pair,
+};
+use structopt::StructOpt;
+use strum::{EnumString, EnumVariantNames, VariantNames};
+
+/// Name of the `NextFreeParaId` value in the `polkadot_runtime_common::paras_registrar` pallet.
+const NEXT_FREE_PARA_ID_STORAGE_NAME: &str = "NextFreeParaId";
+/// Name of the `ParaLifecycles` map in the `polkadot_runtime_parachains::paras` pallet.
+const PARAS_LIFECYCLES_STORAGE_NAME: &str = "ParaLifecycles";
+
+/// Register parachain.
+#[derive(StructOpt, Debug, PartialEq)]
+pub struct RegisterParachain {
+	/// A parachain to register.
+	#[structopt(possible_values = Parachain::VARIANTS, case_insensitive = true)]
+	parachain: Parachain,
+	/// Parachain deposit.
+	#[structopt(long, default_value = "0")]
+	deposit: Balance,
+	/// Lease begin.
+	#[structopt(long, default_value = "0")]
+	lease_begin: u32,
+	/// Lease end.
+	#[structopt(long, default_value = "256")]
+	lease_end: u32,
+	#[structopt(flatten)]
+	relay_connection: RelaychainConnectionParams,
+	#[structopt(flatten)]
+	relay_sign: RelaychainSigningParams,
+	#[structopt(flatten)]
+	para_connection: ParachainConnectionParams,
+}
+
+/// Parachain to register.
+#[derive(Debug, EnumString, EnumVariantNames, PartialEq)]
+#[strum(serialize_all = "kebab_case")]
+pub enum Parachain {
+	RialtoParachain,
+}
+
+macro_rules! select_bridge {
+	($bridge: expr, $generic: tt) => {
+		match $bridge {
+			Parachain::RialtoParachain => {
+				type Relaychain = relay_rialto_client::Rialto;
+				type Parachain = relay_rialto_parachain_client::RialtoParachain;
+
+				use bp_rialto::{PARAS_PALLET_NAME, PARAS_REGISTRAR_PALLET_NAME};
+
+				$generic
+			},
+		}
+	};
+}
+
+impl RegisterParachain {
+	/// Run the command.
+	pub async fn run(self) -> anyhow::Result<()> {
+		select_bridge!(self.parachain, {
+			let relay_client = self.relay_connection.to_client::<Relaychain>().await?;
+			let relay_sign = self.relay_sign.to_keypair::<Relaychain>()?;
+			let para_client = self.para_connection.to_client::<Parachain>().await?;
+
+			// hopefully we're the only actor that is registering parachain right now
+			// => read next parachain id
+			let para_id_key = bp_runtime::storage_value_final_key(
+				PARAS_REGISTRAR_PALLET_NAME.as_bytes(),
+				NEXT_FREE_PARA_ID_STORAGE_NAME.as_bytes(),
+			);
+			let para_id: ParaId = relay_client
+				.storage_value(StorageKey(para_id_key.to_vec()), None)
+				.await?
+				.unwrap_or(polkadot_primitives::v1::LOWEST_PUBLIC_ID)
+				.max(polkadot_primitives::v1::LOWEST_PUBLIC_ID);
+			log::info!(target: "bridge", "Going to reserve parachain id: {:?}", para_id);
+
+			// step 1: reserve a parachain id
+			let relay_genesis_hash = *relay_client.genesis_hash();
+			let relay_sudo_account: AccountIdOf<Relaychain> = relay_sign.public().clone().into();
+			let reserve_parachain_id_call: CallOf<Relaychain> = ParaRegistrarCall::reserve().into();
+			let reserve_parachain_signer = relay_sign.clone();
+			wait_until_transaction_is_finalized::<Relaychain>(
+				relay_client
+					.submit_and_watch_signed_extrinsic(
+						relay_sudo_account.clone(),
+						move |_, transaction_nonce| {
+							Bytes(
+								Relaychain::sign_transaction(
+									relay_genesis_hash,
+									&reserve_parachain_signer,
+									relay_substrate_client::TransactionEra::immortal(),
+									UnsignedTransaction::new(
+										reserve_parachain_id_call,
+										transaction_nonce,
+									),
+								)
+								.encode(),
+							)
+						},
+					)
+					.await?,
+			)
+			.await?;
+			log::info!(target: "bridge", "Reserved parachain id: {:?}", para_id);
+
+			// step 2: register parathread
+			let para_genesis_header = para_client.header_by_number(Zero::zero()).await?;
+			let para_code = para_client
+				.raw_storage_value(StorageKey(CODE.to_vec()), Some(para_genesis_header.hash()))
+				.await?
+				.ok_or_else(|| {
+					anyhow::format_err!("Cannot fetch validation code of {}", Parachain::NAME)
+				})?
+				.0;
+			log::info!(
+				target: "bridge",
+				"Going to register parachain {:?}: genesis len = {} code len = {}",
+				para_id,
+				para_genesis_header.encode().len(),
+				para_code.len(),
+			);
+			let register_parathread_call: CallOf<Relaychain> = ParaRegistrarCall::register(
+				para_id,
+				ParaHeadData(para_genesis_header.encode()),
+				ParaValidationCode(para_code),
+			)
+			.into();
+			let register_parathread_signer = relay_sign.clone();
+			wait_until_transaction_is_finalized::<Relaychain>(
+				relay_client
+					.submit_and_watch_signed_extrinsic(
+						relay_sudo_account.clone(),
+						move |_, transaction_nonce| {
+							Bytes(
+								Relaychain::sign_transaction(
+									relay_genesis_hash,
+									&register_parathread_signer,
+									relay_substrate_client::TransactionEra::immortal(),
+									UnsignedTransaction::new(
+										register_parathread_call,
+										transaction_nonce,
+									),
+								)
+								.encode(),
+							)
+						},
+					)
+					.await?,
+			)
+			.await?;
+			log::info!(target: "bridge", "Registered parachain: {:?}. Waiting for onboarding", para_id);
+
+			// wait until parathread is onboarded
+			let para_state_key = bp_runtime::storage_map_final_key_twox64_concat(
+				PARAS_PALLET_NAME,
+				PARAS_LIFECYCLES_STORAGE_NAME,
+				&para_id.encode(),
+			);
+			wait_para_state(
+				&relay_client,
+				&para_state_key.0,
+				&[ParaLifecycle::Onboarding, ParaLifecycle::Parathread],
+				ParaLifecycle::Parathread,
+			)
+			.await?;
+
+			// step 3: force parachain leases
+			let lease_begin = self.lease_begin;
+			let lease_end = self.lease_end;
+			let para_deposit = self.deposit.cast().into();
+			log::info!(
+				target: "bridge",
+				"Going to force leases of parachain {:?}: [{}; {}]",
+				para_id,
+				lease_begin,
+				lease_end,
+			);
+			let force_lease_call: CallOf<Relaychain> = SudoCall::sudo(Box::new(
+				ParaSlotsCall::force_lease(
+					para_id,
+					relay_sudo_account.clone(),
+					para_deposit,
+					lease_begin,
+					lease_end,
+				)
+				.into(),
+			))
+			.into();
+			let force_lease_signer = relay_sign.clone();
+			relay_client
+				.submit_signed_extrinsic(relay_sudo_account.clone(), move |_, transaction_nonce| {
+					Bytes(
+						Relaychain::sign_transaction(
+							relay_genesis_hash,
+							&force_lease_signer,
+							relay_substrate_client::TransactionEra::immortal(),
+							UnsignedTransaction::new(force_lease_call, transaction_nonce),
+						)
+						.encode(),
+					)
+				})
+				.await?;
+			log::info!(target: "bridge", "Registered parachain leases: {:?}. Waiting for onboarding", para_id);
+
+			// wait until parachain is onboarded
+			wait_para_state(
+				&relay_client,
+				&para_state_key.0,
+				&[
+					ParaLifecycle::Onboarding,
+					ParaLifecycle::UpgradingParathread,
+					ParaLifecycle::Parathread,
+				],
+				ParaLifecycle::Parachain,
+			)
+			.await?;
+
+			Ok(())
+		})
+	}
+}
+
+/// Wait until parachain state is changed.
+async fn wait_para_state<Relaychain: Chain>(
+	relay_client: &Client<Relaychain>,
+	para_state_key: &[u8],
+	from_states: &[ParaLifecycle],
+	to_state: ParaLifecycle,
+) -> anyhow::Result<()> {
+	loop {
+		let para_state: ParaLifecycle = relay_client
+			.storage_value(StorageKey(para_state_key.to_vec()), None)
+			.await?
+			.ok_or_else(|| {
+				anyhow::format_err!(
+					"Cannot fetch next free parachain lifecycle from the runtime storage of {}",
+					Relaychain::NAME,
+				)
+			})?;
+		if !from_states.contains(&para_state) {
+			return Err(anyhow::format_err!("Invalid parachain lifecycle: {:?}", para_state))
+		}
+		if para_state == to_state {
+			log::info!(target: "bridge", "Parachain state is now: {:?}", to_state);
+			return Ok(())
+		}
+
+		log::info!(target: "bridge", "Parachain state: {:?}. Waiting for {:?}", para_state, to_state);
+		async_std::task::sleep(Relaychain::AVERAGE_BLOCK_INTERVAL).await;
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn register_rialto_parachain() {
+		let register_parachain = RegisterParachain::from_iter(vec![
+			"register-parachain",
+			"rialto-parachain",
+			"--parachain-host",
+			"127.0.0.1",
+			"--parachain-port",
+			"11949",
+			"--relaychain-host",
+			"127.0.0.1",
+			"--relaychain-port",
+			"9944",
+			"--relaychain-signer",
+			"//Alice",
+			"--deposit",
+			"42",
+			"--lease-begin",
+			"100",
+			"--lease-end",
+			"200",
+		]);
+
+		assert_eq!(
+			register_parachain,
+			RegisterParachain {
+				parachain: Parachain::RialtoParachain,
+				deposit: Balance(42),
+				lease_begin: 100,
+				lease_end: 200,
+				relay_connection: RelaychainConnectionParams {
+					relaychain_host: "127.0.0.1".into(),
+					relaychain_port: 9944,
+					relaychain_secure: false,
+				},
+				relay_sign: RelaychainSigningParams {
+					relaychain_signer: Some("//Alice".into()),
+					relaychain_signer_password: None,
+					relaychain_signer_file: None,
+					relaychain_signer_password_file: None,
+					relaychain_transactions_mortality: None,
+				},
+				para_connection: ParachainConnectionParams {
+					parachain_host: "127.0.0.1".into(),
+					parachain_port: 11949,
+					parachain_secure: false,
+				},
+			}
+		);
+	}
+}

bridges/relays/bin-substrate/src/cli/swap_tokens.rs

@@ -570,7 +570,7 @@ async fn read_account_balance<C: ChainWithBalances>(
 /// Wait until transaction is included into finalized block.
 ///
 /// Returns the hash of the finalized block with transaction.
-async fn wait_until_transaction_is_finalized<C: Chain>(
+pub(crate) async fn wait_until_transaction_is_finalized<C: Chain>(
 	subscription: Subscription<TransactionStatusOf<C>>,
 ) -> anyhow::Result<HashOf<C>> {
 	loop {