Adding Bridges code as git subtree. (#2515)

* Add instructions.

* Squashed 'bridges/' content from commit 345e84a21

git-subtree-dir: bridges
git-subtree-split: 345e84a2146b56628e9888c9f5e129cb40e868a9

* Remove bridges workspace file to avoid confusing Cargo.

* Add some bridges primitives to Polkadot workspace.

* Improve docs.

polkadot/bridges/bin/millau/node/Cargo.toml

@@ -0,0 +1,61 @@
+[package]
+name = "millau-bridge-node"
+description = "Substrate node compatible with Millau runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+build = "build.rs"
+homepage = "https://substrate.dev"
+repository = "https://github.com/paritytech/parity-bridges-common/"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+jsonrpc-core = "15.1.0"
+structopt = "0.3.21"
+
+# Bridge dependencies
+
+bp-message-lane = { path = "../../../primitives/message-lane" }
+bp-millau= { path = "../../../primitives/millau" }
+bp-runtime = { path = "../../../primitives/runtime" }
+millau-runtime = { path = "../runtime" }
+pallet-message-lane = { path = "../../../modules/message-lane" }
+pallet-message-lane-rpc = { path = "../../../modules/message-lane/rpc" }
+
+# Substrate Dependencies
+
+frame-benchmarking = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+frame-benchmarking-cli = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-basic-authorship = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-cli = { git = "https://github.com/paritytech/substrate.git", branch = "master", features = ["wasmtime"] }
+sc-client-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-consensus = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-consensus-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-executor = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-finality-grandpa-rpc = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-keystore = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-service = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-rpc = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-transaction-pool = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-consensus = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-consensus-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-core = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-inherents = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-runtime = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+substrate-frame-rpc-system = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+
+[build-dependencies]
+build-script-utils = { package = "substrate-build-script-utils", version = "2.0" }
+frame-benchmarking-cli = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+vergen = "3.1.0"
+
+[features]
+default = []
+
+# TODO: https://github.com/paritytech/parity-bridges-common/issues/390
+# I've left the feature flag here to test our CI configuration
+runtime-benchmarks = [
+	# "millau-runtime/runtime-benchmarks",
+]

polkadot/bridges/bin/millau/node/build.rs

@@ -0,0 +1,25 @@
+// Copyright 2019-2020 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 vergen::{generate_cargo_keys, ConstantsFlags};
+
+const ERROR_MSG: &str = "Failed to generate metadata files";
+
+fn main() {
+	generate_cargo_keys(ConstantsFlags::SHA_SHORT).expect(ERROR_MSG);
+
+	build_script_utils::rerun_if_git_head_changed();
+}

polkadot/bridges/bin/millau/node/src/chain_spec.rs

@@ -0,0 +1,190 @@
+// Copyright 2019-2020 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 bp_millau::derive_account_from_rialto_id;
+use millau_runtime::{
+	AccountId, AuraConfig, BalancesConfig, BridgeRialtoConfig, GenesisConfig, GrandpaConfig, SessionConfig,
+	SessionKeys, Signature, SudoConfig, SystemConfig, WASM_BINARY,
+};
+use sp_consensus_aura::sr25519::AuthorityId as AuraId;
+use sp_core::{sr25519, Pair, Public};
+use sp_finality_grandpa::AuthorityId as GrandpaId;
+use sp_runtime::traits::{IdentifyAccount, Verify};
+
+/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
+pub type ChainSpec = sc_service::GenericChainSpec<GenesisConfig>;
+
+/// The chain specification option. This is expected to come in from the CLI and
+/// is little more than one of a number of alternatives which can easily be converted
+/// from a string (`--chain=...`) into a `ChainSpec`.
+#[derive(Clone, Debug)]
+pub enum Alternative {
+	/// Whatever the current runtime is, with just Alice as an auth.
+	Development,
+	/// Whatever the current runtime is, with simple Alice/Bob/Charlie/Dave/Eve auths.
+	LocalTestnet,
+}
+
+/// Helper function to generate a crypto pair from seed
+pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
+		.expect("static values are valid; qed")
+		.public()
+}
+
+type AccountPublic = <Signature as Verify>::Signer;
+
+/// Helper function to generate an account ID from seed
+pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
+where
+	AccountPublic: From<<TPublic::Pair as Pair>::Public>,
+{
+	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
+}
+
+/// Helper function to generate an authority key for Aura
+pub fn get_authority_keys_from_seed(s: &str) -> (AccountId, AuraId, GrandpaId) {
+	(
+		get_account_id_from_seed::<sr25519::Public>(s),
+		get_from_seed::<AuraId>(s),
+		get_from_seed::<GrandpaId>(s),
+	)
+}
+
+impl Alternative {
+	/// Get an actual chain config from one of the alternatives.
+	pub(crate) fn load(self) -> ChainSpec {
+		match self {
+			Alternative::Development => ChainSpec::from_genesis(
+				"Development",
+				"dev",
+				sc_service::ChainType::Development,
+				|| {
+					testnet_genesis(
+						vec![get_authority_keys_from_seed("Alice")],
+						get_account_id_from_seed::<sr25519::Public>("Alice"),
+						vec![
+							get_account_id_from_seed::<sr25519::Public>("Alice"),
+							get_account_id_from_seed::<sr25519::Public>("Bob"),
+							get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+						],
+						true,
+					)
+				},
+				vec![],
+				None,
+				None,
+				None,
+				None,
+			),
+			Alternative::LocalTestnet => ChainSpec::from_genesis(
+				"Local Testnet",
+				"local_testnet",
+				sc_service::ChainType::Local,
+				|| {
+					testnet_genesis(
+						vec![
+							get_authority_keys_from_seed("Alice"),
+							get_authority_keys_from_seed("Bob"),
+							get_authority_keys_from_seed("Charlie"),
+							get_authority_keys_from_seed("Dave"),
+							get_authority_keys_from_seed("Eve"),
+						],
+						get_account_id_from_seed::<sr25519::Public>("Alice"),
+						vec![
+							get_account_id_from_seed::<sr25519::Public>("Alice"),
+							get_account_id_from_seed::<sr25519::Public>("Bob"),
+							get_account_id_from_seed::<sr25519::Public>("Charlie"),
+							get_account_id_from_seed::<sr25519::Public>("Dave"),
+							get_account_id_from_seed::<sr25519::Public>("Eve"),
+							get_account_id_from_seed::<sr25519::Public>("Ferdie"),
+							get_account_id_from_seed::<sr25519::Public>("George"),
+							get_account_id_from_seed::<sr25519::Public>("Harry"),
+							get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
+							get_account_id_from_seed::<sr25519::Public>("George//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
+							pallet_message_lane::Module::<millau_runtime::Runtime, pallet_message_lane::DefaultInstance>::relayer_fund_account_id(),
+							derive_account_from_rialto_id(bp_runtime::SourceAccount::Account(
+								get_account_id_from_seed::<sr25519::Public>("Dave"),
+							)),
+						],
+						true,
+					)
+				},
+				vec![],
+				None,
+				None,
+				None,
+				None,
+			),
+		}
+	}
+}
+
+fn session_keys(aura: AuraId, grandpa: GrandpaId) -> SessionKeys {
+	SessionKeys { aura, grandpa }
+}
+
+fn testnet_genesis(
+	initial_authorities: Vec<(AccountId, AuraId, GrandpaId)>,
+	root_key: AccountId,
+	endowed_accounts: Vec<AccountId>,
+	_enable_println: bool,
+) -> GenesisConfig {
+	GenesisConfig {
+		frame_system: Some(SystemConfig {
+			code: WASM_BINARY.to_vec(),
+			changes_trie_config: Default::default(),
+		}),
+		pallet_balances: Some(BalancesConfig {
+			balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 50)).collect(),
+		}),
+		pallet_aura: Some(AuraConfig {
+			authorities: Vec::new(),
+		}),
+		pallet_grandpa: Some(GrandpaConfig {
+			authorities: Vec::new(),
+		}),
+		pallet_substrate_bridge: Some(BridgeRialtoConfig {
+			// We'll initialize the pallet with a dispatchable instead.
+			init_data: None,
+			owner: Some(root_key.clone()),
+		}),
+		pallet_sudo: Some(SudoConfig { key: root_key }),
+		pallet_session: Some(SessionConfig {
+			keys: initial_authorities
+				.iter()
+				.map(|x| (x.0.clone(), x.0.clone(), session_keys(x.1.clone(), x.2.clone())))
+				.collect::<Vec<_>>(),
+		}),
+	}
+}
+
+#[test]
+fn derived_dave_account_is_as_expected() {
+	let dave = get_account_id_from_seed::<sr25519::Public>("Dave");
+	let derived: AccountId = derive_account_from_rialto_id(bp_runtime::SourceAccount::Account(dave));
+	assert_eq!(
+		derived.to_string(),
+		"5DNW6UVnb7TN6wX5KwXtDYR3Eccecbdzuw89HqjyNfkzce6J".to_string()
+	);
+}

polkadot/bridges/bin/millau/node/src/cli.rs

@@ -0,0 +1,67 @@
+// Copyright 2019-2020 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 sc_cli::RunCmd;
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+pub struct Cli {
+	#[structopt(subcommand)]
+	pub subcommand: Option<Subcommand>,
+
+	#[structopt(flatten)]
+	pub run: RunCmd,
+}
+
+/// Possible subcommands of the main binary.
+#[derive(Debug, StructOpt)]
+pub enum Subcommand {
+	/// Key management cli utilities
+	Key(sc_cli::KeySubcommand),
+	/// Verify a signature for a message, provided on STDIN, with a given (public or secret) key.
+	Verify(sc_cli::VerifyCmd),
+
+	/// Generate a seed that provides a vanity address.
+	Vanity(sc_cli::VanityCmd),
+
+	/// Sign a message, with a given (secret) key.
+	Sign(sc_cli::SignCmd),
+
+	/// Build a chain specification.
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
+
+	/// The custom benchmark subcommmand benchmarking runtime pallets.
+	#[structopt(name = "benchmark", about = "Benchmark runtime pallets.")]
+	Benchmark(frame_benchmarking_cli::BenchmarkCmd),
+}

polkadot/bridges/bin/millau/node/src/command.rs

@@ -0,0 +1,168 @@
+// Copyright 2019-2020 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::{Cli, Subcommand};
+use crate::service;
+use crate::service::new_partial;
+use millau_runtime::Block;
+use sc_cli::{ChainSpec, Role, RuntimeVersion, SubstrateCli};
+use sc_service::PartialComponents;
+
+impl SubstrateCli for Cli {
+	fn impl_name() -> String {
+		"Millau Bridge Node".into()
+	}
+
+	fn impl_version() -> String {
+		env!("CARGO_PKG_VERSION").into()
+	}
+
+	fn description() -> String {
+		"Millau Bridge Node".into()
+	}
+
+	fn author() -> String {
+		"Parity Technologies".into()
+	}
+
+	fn support_url() -> String {
+		"https://github.com/paritytech/parity-bridges-common/".into()
+	}
+
+	fn copyright_start_year() -> i32 {
+		2019
+	}
+
+	fn executable_name() -> String {
+		"millau-bridge-node".into()
+	}
+
+	fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
+		&millau_runtime::VERSION
+	}
+
+	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+		Ok(Box::new(
+			match id {
+				"" | "dev" => crate::chain_spec::Alternative::Development,
+				"local" => crate::chain_spec::Alternative::LocalTestnet,
+				_ => return Err(format!("Unsupported chain specification: {}", id)),
+			}
+			.load(),
+		))
+	}
+}
+
+/// Parse and run command line arguments
+pub fn run() -> sc_cli::Result<()> {
+	let cli = Cli::from_args();
+	// make sure to set correct crypto version.
+	sp_core::crypto::set_default_ss58_version(sp_core::crypto::Ss58AddressFormat::Custom(
+		millau_runtime::SS58Prefix::get() as u16,
+	));
+
+	match &cli.subcommand {
+		Some(Subcommand::Benchmark(cmd)) => {
+			if cfg!(feature = "runtime-benchmarks") {
+				let runner = cli.create_runner(cmd)?;
+
+				runner.sync_run(|config| cmd.run::<Block, service::Executor>(config))
+			} else {
+				println!(
+					"Benchmarking wasn't enabled when building the node. \
+				You can enable it with `--features runtime-benchmarks`."
+				);
+				Ok(())
+			}
+		}
+		Some(Subcommand::Key(cmd)) => cmd.run(&cli),
+		Some(Subcommand::Sign(cmd)) => cmd.run(),
+		Some(Subcommand::Verify(cmd)) => cmd.run(),
+		Some(Subcommand::Vanity(cmd)) => cmd.run(),
+		Some(Subcommand::BuildSpec(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
+		}
+		Some(Subcommand::CheckBlock(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client,
+					task_manager,
+					import_queue,
+					..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		}
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client, task_manager, ..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		}
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client, task_manager, ..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		}
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client,
+					task_manager,
+					import_queue,
+					..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		}
+		Some(Subcommand::PurgeChain(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.database))
+		}
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client,
+					task_manager,
+					backend,
+					..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, backend), task_manager))
+			})
+		}
+		None => {
+			let runner = cli.create_runner(&cli.run)?;
+			runner.run_node_until_exit(|config| async move {
+				match config.role {
+					Role::Light => service::new_light(config),
+					_ => service::new_full(config),
+				}
+				.map_err(sc_cli::Error::Service)
+			})
+		}
+	}
+}

polkadot/bridges/bin/millau/node/src/lib.rs

@@ -0,0 +1,32 @@
+// Copyright 2019-2020 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/>.
+
+//! Substrate Node Template CLI library.
+#![warn(missing_docs)]
+
+mod chain_spec;
+#[macro_use]
+mod service;
+mod cli;
+mod command;
+
+/// Node run result.
+pub type Result = sc_cli::Result<()>;
+
+/// Run node.
+pub fn run() -> Result {
+	command::run()
+}

polkadot/bridges/bin/millau/node/src/main.rs

@@ -0,0 +1,30 @@
+// Copyright 2019-2020 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/>.
+
+//! Millau bridge node.
+
+#![warn(missing_docs)]
+
+mod chain_spec;
+#[macro_use]
+mod service;
+mod cli;
+mod command;
+
+/// Run the Millau Node
+fn main() -> sc_cli::Result<()> {
+	command::run()
+}

polkadot/bridges/bin/millau/node/src/service.rs

@@ -0,0 +1,433 @@
+// Copyright 2019-2020 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/>.
+
+//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+// UPDATE GUIDE:
+// 1) replace everything with node-template/src/service.rs contents (found in main Substrate repo);
+// 2) the only thing to keep from old code, is `rpc_extensions_builder` - we use our own custom RPCs;
+// 3) fix compilation errors;
+// 4) test :)
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+
+use millau_runtime::{self, opaque::Block, RuntimeApi};
+use sc_client_api::{ExecutorProvider, RemoteBackend};
+use sc_executor::native_executor_instance;
+pub use sc_executor::NativeExecutor;
+use sc_finality_grandpa::SharedVoterState;
+use sc_keystore::LocalKeystore;
+use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
+use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
+use sp_inherents::InherentDataProviders;
+use std::sync::Arc;
+use std::time::Duration;
+
+// Our native executor instance.
+native_executor_instance!(
+	pub Executor,
+	millau_runtime::api::dispatch,
+	millau_runtime::native_version,
+	frame_benchmarking::benchmarking::HostFunctions,
+);
+
+type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
+type FullBackend = sc_service::TFullBackend<Block>;
+type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
+
+#[allow(clippy::type_complexity)]
+pub fn new_partial(
+	config: &Configuration,
+) -> Result<
+	sc_service::PartialComponents<
+		FullClient,
+		FullBackend,
+		FullSelectChain,
+		sp_consensus::DefaultImportQueue<Block, FullClient>,
+		sc_transaction_pool::FullPool<Block, FullClient>,
+		(
+			sc_consensus_aura::AuraBlockImport<
+				Block,
+				FullClient,
+				sc_finality_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>,
+				AuraPair,
+			>,
+			sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+		),
+	>,
+	ServiceError,
+> {
+	if config.keystore_remote.is_some() {
+		return Err(ServiceError::Other("Remote Keystores are not supported.".to_string()));
+	}
+	let inherent_data_providers = sp_inherents::InherentDataProviders::new();
+
+	let (client, backend, keystore_container, task_manager) =
+		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
+	let client = Arc::new(client);
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
+		config.transaction_pool.clone(),
+		config.role.is_authority().into(),
+		config.prometheus_registry(),
+		task_manager.spawn_handle(),
+		client.clone(),
+	);
+
+	let (grandpa_block_import, grandpa_link) =
+		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain.clone())?;
+
+	let aura_block_import =
+		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
+
+	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
+		sc_consensus_aura::slot_duration(&*client)?,
+		aura_block_import.clone(),
+		Some(Box::new(grandpa_block_import)),
+		client.clone(),
+		inherent_data_providers.clone(),
+		&task_manager.spawn_essential_handle(),
+		config.prometheus_registry(),
+		sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
+	)?;
+
+	Ok(sc_service::PartialComponents {
+		client,
+		backend,
+		task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		inherent_data_providers,
+		other: (aura_block_import, grandpa_link),
+	})
+}
+
+fn remote_keystore(_url: &str) -> Result<Arc<LocalKeystore>, &'static str> {
+	// FIXME: here would the concrete keystore be built,
+	//        must return a concrete type (NOT `LocalKeystore`) that
+	//        implements `CryptoStore` and `SyncCryptoStore`
+	Err("Remote Keystore not supported.")
+}
+
+/// Builds a new service for a full client.
+pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError> {
+	let sc_service::PartialComponents {
+		client,
+		backend,
+		mut task_manager,
+		import_queue,
+		mut keystore_container,
+		select_chain,
+		transaction_pool,
+		inherent_data_providers,
+		other: (block_import, grandpa_link),
+	} = new_partial(&config)?;
+
+	if let Some(url) = &config.keystore_remote {
+		match remote_keystore(url) {
+			Ok(k) => keystore_container.set_remote_keystore(k),
+			Err(e) => {
+				return Err(ServiceError::Other(format!(
+					"Error hooking up remote keystore for {}: {}",
+					url, e
+				)))
+			}
+		};
+	}
+
+	config
+		.network
+		.extra_sets
+		.push(sc_finality_grandpa::grandpa_peers_set_config());
+
+	let (network, network_status_sinks, system_rpc_tx, network_starter) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			on_demand: None,
+			block_announce_validator_builder: None,
+		})?;
+
+	if config.offchain_worker.enabled {
+		sc_service::build_offchain_workers(
+			&config,
+			backend.clone(),
+			task_manager.spawn_handle(),
+			client.clone(),
+			network.clone(),
+		);
+	}
+
+	let role = config.role.clone();
+	let force_authoring = config.force_authoring;
+	let backoff_authoring_blocks: Option<()> = None;
+	let name = config.network.node_name.clone();
+	let enable_grandpa = !config.disable_grandpa;
+	let prometheus_registry = config.prometheus_registry().cloned();
+
+	let rpc_extensions_builder = {
+		use bp_message_lane::{LaneId, MessageNonce};
+		use bp_runtime::{InstanceId, RIALTO_BRIDGE_INSTANCE};
+		use sc_finality_grandpa::FinalityProofProvider as GrandpaFinalityProofProvider;
+		use sp_core::storage::StorageKey;
+
+		// This struct is here to ease update process.
+
+		/// Millau runtime from message-lane RPC point of view.
+		struct MillauMessageLaneKeys;
+
+		impl pallet_message_lane_rpc::Runtime for MillauMessageLaneKeys {
+			fn message_key(&self, instance: &InstanceId, lane: &LaneId, nonce: MessageNonce) -> Option<StorageKey> {
+				match *instance {
+					RIALTO_BRIDGE_INSTANCE => Some(millau_runtime::rialto_messages::message_key(lane, nonce)),
+					_ => None,
+				}
+			}
+
+			fn outbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					RIALTO_BRIDGE_INSTANCE => Some(millau_runtime::rialto_messages::outbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+
+			fn inbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					RIALTO_BRIDGE_INSTANCE => Some(millau_runtime::rialto_messages::inbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+		}
+
+		use pallet_message_lane_rpc::{MessageLaneApi, MessageLaneRpcHandler};
+		use sc_finality_grandpa_rpc::{GrandpaApi, GrandpaRpcHandler};
+		use sc_rpc::DenyUnsafe;
+		use substrate_frame_rpc_system::{FullSystem, SystemApi};
+
+		let backend = backend.clone();
+		let client = client.clone();
+		let pool = transaction_pool.clone();
+
+		let justification_stream = grandpa_link.justification_stream();
+		let shared_authority_set = grandpa_link.shared_authority_set().clone();
+		let shared_voter_state = sc_finality_grandpa::SharedVoterState::empty();
+
+		let finality_proof_provider =
+			GrandpaFinalityProofProvider::new_for_service(backend.clone(), Some(shared_authority_set.clone()));
+
+		Box::new(move |_, subscription_executor| {
+			let mut io = jsonrpc_core::IoHandler::default();
+			io.extend_with(SystemApi::to_delegate(FullSystem::new(
+				client.clone(),
+				pool.clone(),
+				DenyUnsafe::No,
+			)));
+			io.extend_with(GrandpaApi::to_delegate(GrandpaRpcHandler::new(
+				shared_authority_set.clone(),
+				shared_voter_state.clone(),
+				justification_stream.clone(),
+				subscription_executor,
+				finality_proof_provider.clone(),
+			)));
+			io.extend_with(MessageLaneApi::to_delegate(MessageLaneRpcHandler::new(
+				backend.clone(),
+				Arc::new(MillauMessageLaneKeys),
+			)));
+
+			io
+		})
+	};
+
+	let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		network: network.clone(),
+		client: client.clone(),
+		keystore: keystore_container.sync_keystore(),
+		task_manager: &mut task_manager,
+		transaction_pool: transaction_pool.clone(),
+		rpc_extensions_builder,
+		on_demand: None,
+		remote_blockchain: None,
+		backend,
+		network_status_sinks,
+		system_rpc_tx,
+		config,
+		telemetry_span: None,
+	})?;
+
+	if role.is_authority() {
+		let proposer = sc_basic_authorship::ProposerFactory::new(
+			task_manager.spawn_handle(),
+			client.clone(),
+			transaction_pool,
+			prometheus_registry.as_ref(),
+		);
+
+		let can_author_with = sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
+
+		let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _, _>(
+			sc_consensus_aura::slot_duration(&*client)?,
+			client.clone(),
+			select_chain,
+			block_import,
+			proposer,
+			network.clone(),
+			inherent_data_providers,
+			force_authoring,
+			backoff_authoring_blocks,
+			keystore_container.sync_keystore(),
+			can_author_with,
+		)?;
+
+		// the AURA authoring task is considered essential, i.e. if it
+		// fails we take down the service with it.
+		task_manager.spawn_essential_handle().spawn_blocking("aura", aura);
+	}
+
+	// if the node isn't actively participating in consensus then it doesn't
+	// need a keystore, regardless of which protocol we use below.
+	let keystore = if role.is_authority() {
+		Some(keystore_container.sync_keystore())
+	} else {
+		None
+	};
+
+	let grandpa_config = sc_finality_grandpa::Config {
+		// FIXME #1578 make this available through chainspec
+		gossip_duration: Duration::from_millis(333),
+		justification_period: 512,
+		name: Some(name),
+		observer_enabled: false,
+		keystore,
+		is_authority: role.is_authority(),
+	};
+
+	if enable_grandpa {
+		// start the full GRANDPA voter
+		// NOTE: non-authorities could run the GRANDPA observer protocol, but at
+		// this point the full voter should provide better guarantees of block
+		// and vote data availability than the observer. The observer has not
+		// been tested extensively yet and having most nodes in a network run it
+		// could lead to finality stalls.
+		let grandpa_config = sc_finality_grandpa::GrandpaParams {
+			config: grandpa_config,
+			link: grandpa_link,
+			network,
+			telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),
+			voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
+			prometheus_registry,
+			shared_voter_state: SharedVoterState::empty(),
+		};
+
+		// the GRANDPA voter task is considered infallible, i.e.
+		// if it fails we take down the service with it.
+		task_manager
+			.spawn_essential_handle()
+			.spawn_blocking("grandpa-voter", sc_finality_grandpa::run_grandpa_voter(grandpa_config)?);
+	}
+
+	network_starter.start_network();
+	Ok(task_manager)
+}
+
+/// Builds a new service for a light client.
+pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError> {
+	let (client, backend, keystore_container, mut task_manager, on_demand) =
+		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+
+	config
+		.network
+		.extra_sets
+		.push(sc_finality_grandpa::grandpa_peers_set_config());
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = Arc::new(sc_transaction_pool::BasicPool::new_light(
+		config.transaction_pool.clone(),
+		config.prometheus_registry(),
+		task_manager.spawn_handle(),
+		client.clone(),
+		on_demand.clone(),
+	));
+
+	let (grandpa_block_import, _) =
+		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain)?;
+
+	let aura_block_import =
+		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
+
+	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
+		sc_consensus_aura::slot_duration(&*client)?,
+		aura_block_import,
+		Some(Box::new(grandpa_block_import)),
+		client.clone(),
+		InherentDataProviders::new(),
+		&task_manager.spawn_essential_handle(),
+		config.prometheus_registry(),
+		sp_consensus::NeverCanAuthor,
+	)?;
+
+	let (network, network_status_sinks, system_rpc_tx, network_starter) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			on_demand: Some(on_demand.clone()),
+			block_announce_validator_builder: None,
+		})?;
+
+	if config.offchain_worker.enabled {
+		sc_service::build_offchain_workers(
+			&config,
+			backend.clone(),
+			task_manager.spawn_handle(),
+			client.clone(),
+			network.clone(),
+		);
+	}
+
+	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		remote_blockchain: Some(backend.remote_blockchain()),
+		transaction_pool,
+		task_manager: &mut task_manager,
+		on_demand: Some(on_demand),
+		rpc_extensions_builder: Box::new(|_, _| ()),
+		config,
+		client,
+		keystore: keystore_container.sync_keystore(),
+		backend,
+		network,
+		network_status_sinks,
+		system_rpc_tx,
+		telemetry_span: None,
+	})?;
+
+	network_starter.start_network();
+
+	Ok(task_manager)
+}

polkadot/bridges/bin/millau/runtime/Cargo.toml

@@ -0,0 +1,101 @@
+[package]
+name = "millau-runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+homepage = "https://substrate.dev"
+repository = "https://github.com/paritytech/parity-bridges-common/"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] }
+hex-literal = "0.3"
+serde = { version = "1.0.123", optional = true, features = ["derive"] }
+
+# Bridge dependencies
+
+bp-header-chain = { path = "../../../primitives/header-chain", default-features = false }
+bp-message-lane = { path = "../../../primitives/message-lane", default-features = false }
+bp-millau = { path = "../../../primitives/millau", default-features = false }
+bp-rialto = { path = "../../../primitives/rialto", default-features = false }
+bp-runtime = { path = "../../../primitives/runtime", default-features = false }
+bridge-runtime-common = { path = "../../runtime-common", default-features = false }
+pallet-bridge-call-dispatch = { path = "../../../modules/call-dispatch", default-features = false }
+pallet-finality-verifier = { path = "../../../modules/finality-verifier", default-features = false }
+pallet-message-lane = { path = "../../../modules/message-lane", default-features = false }
+pallet-shift-session-manager = { path = "../../../modules/shift-session-manager", default-features = false }
+pallet-substrate-bridge = { path = "../../../modules/substrate", default-features = false }
+
+# Substrate Dependencies
+
+frame-executive = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-support = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-system = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-balances = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-randomness-collective-flip = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-session = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-sudo = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-timestamp = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-transaction-payment = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-block-builder = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-consensus-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-core = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-inherents = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-offchain = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-session = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-std = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-transaction-pool = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-trie = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-version = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+
+[build-dependencies]
+wasm-builder-runner = { package = "substrate-wasm-builder-runner", version = "2.0.0" }
+
+[features]
+default = ["std"]
+std = [
+	"bp-header-chain/std",
+	"bp-message-lane/std",
+	"bp-millau/std",
+	"bp-rialto/std",
+	"bp-runtime/std",
+	"bridge-runtime-common/std",
+	"codec/std",
+	"frame-executive/std",
+	"frame-support/std",
+	"frame-system/std",
+	"frame-system-rpc-runtime-api/std",
+	"pallet-aura/std",
+	"pallet-balances/std",
+	"pallet-bridge-call-dispatch/std",
+	"pallet-finality-verifier/std",
+	"pallet-grandpa/std",
+	"pallet-message-lane/std",
+	"pallet-randomness-collective-flip/std",
+	"pallet-shift-session-manager/std",
+	"pallet-session/std",
+	"pallet-substrate-bridge/std",
+	"pallet-sudo/std",
+	"pallet-timestamp/std",
+	"pallet-transaction-payment/std",
+	"serde",
+	"sp-api/std",
+	"sp-block-builder/std",
+	"sp-consensus-aura/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-finality-grandpa/std",
+	"sp-offchain/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-std/std",
+	"sp-transaction-pool/std",
+	"sp-trie/std",
+	"sp-version/std",
+]

polkadot/bridges/bin/millau/runtime/build.rs

@@ -0,0 +1,26 @@
+// Copyright 2019-2020 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 wasm_builder_runner::WasmBuilder;
+
+fn main() {
+	WasmBuilder::new()
+		.with_current_project()
+		.with_wasm_builder_from_crates("1.0.11")
+		.export_heap_base()
+		.import_memory()
+		.build()
+}

polkadot/bridges/bin/millau/runtime/src/lib.rs

@@ -0,0 +1,684 @@
+// Copyright 2019-2020 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/>.
+
+//! The Millau runtime. This can be compiled with `#[no_std]`, ready for Wasm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
+#![recursion_limit = "256"]
+// Runtime-generated enums
+#![allow(clippy::large_enum_variant)]
+// Runtime-generated DecodeLimit::decode_all_With_depth_limit
+#![allow(clippy::unnecessary_mut_passed)]
+// From construct_runtime macro
+#![allow(clippy::from_over_into)]
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+pub mod rialto_messages;
+
+use crate::rialto_messages::{ToRialtoMessagePayload, WithRialtoMessageBridge};
+
+use bridge_runtime_common::messages::{source::estimate_message_dispatch_and_delivery_fee, MessageBridge};
+use codec::Decode;
+use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList};
+use sp_api::impl_runtime_apis;
+use sp_consensus_aura::sr25519::AuthorityId as AuraId;
+use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
+use sp_runtime::traits::{Block as BlockT, IdentityLookup, NumberFor, OpaqueKeys};
+use sp_runtime::{
+	create_runtime_str, generic, impl_opaque_keys,
+	transaction_validity::{TransactionSource, TransactionValidity},
+	ApplyExtrinsicResult, MultiSignature, MultiSigner,
+};
+use sp_std::prelude::*;
+#[cfg(feature = "std")]
+use sp_version::NativeVersion;
+use sp_version::RuntimeVersion;
+
+// A few exports that help ease life for downstream crates.
+pub use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{Currency, ExistenceRequirement, Imbalance, KeyOwnerProofSystem, Randomness},
+	weights::{constants::WEIGHT_PER_SECOND, DispatchClass, IdentityFee, RuntimeDbWeight, Weight},
+	StorageValue,
+};
+
+pub use frame_system::Call as SystemCall;
+pub use pallet_balances::Call as BalancesCall;
+pub use pallet_message_lane::Call as MessageLaneCall;
+pub use pallet_substrate_bridge::Call as BridgeRialtoCall;
+pub use pallet_sudo::Call as SudoCall;
+pub use pallet_timestamp::Call as TimestampCall;
+
+#[cfg(any(feature = "std", test))]
+pub use sp_runtime::BuildStorage;
+pub use sp_runtime::{Perbill, Permill};
+
+/// An index to a block.
+pub type BlockNumber = bp_millau::BlockNumber;
+
+/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
+pub type Signature = bp_millau::Signature;
+
+/// Some way of identifying an account on the chain. We intentionally make it equivalent
+/// to the public key of our transaction signing scheme.
+pub type AccountId = bp_millau::AccountId;
+
+/// The type for looking up accounts. We don't expect more than 4 billion of them, but you
+/// never know...
+pub type AccountIndex = u32;
+
+/// Balance of an account.
+pub type Balance = bp_millau::Balance;
+
+/// Index of a transaction in the chain.
+pub type Index = u32;
+
+/// A hash of some data used by the chain.
+pub type Hash = bp_millau::Hash;
+
+/// Hashing algorithm used by the chain.
+pub type Hashing = bp_millau::Hasher;
+
+/// Digest item type.
+pub type DigestItem = generic::DigestItem<Hash>;
+
+/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
+/// the specifics of the runtime. They can then be made to be agnostic over specific formats
+/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
+/// to even the core data structures.
+pub mod opaque {
+	use super::*;
+
+	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
+
+	/// Opaque block header type.
+	pub type Header = generic::Header<BlockNumber, Hashing>;
+	/// Opaque block type.
+	pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+	/// Opaque block identifier type.
+	pub type BlockId = generic::BlockId<Block>;
+}
+
+impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub aura: Aura,
+		pub grandpa: Grandpa,
+	}
+}
+
+/// This runtime version.
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: create_runtime_str!("millau-runtime"),
+	impl_name: create_runtime_str!("millau-runtime"),
+	authoring_version: 1,
+	spec_version: 1,
+	impl_version: 1,
+	apis: RUNTIME_API_VERSIONS,
+	transaction_version: 1,
+};
+
+/// The version information used to identify this runtime when compiled natively.
+#[cfg(feature = "std")]
+pub fn native_version() -> NativeVersion {
+	NativeVersion {
+		runtime_version: VERSION,
+		can_author_with: Default::default(),
+	}
+}
+
+parameter_types! {
+	pub const BlockHashCount: BlockNumber = 250;
+	pub const Version: RuntimeVersion = VERSION;
+	pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight {
+		read: 60_000_000, // ~0.06 ms = ~60 µs
+		write: 200_000_000, // ~0.2 ms = 200 µs
+	};
+	pub const SS58Prefix: u8 = 60;
+}
+
+impl frame_system::Config for Runtime {
+	/// The basic call filter to use in dispatchable.
+	type BaseCallFilter = ();
+	/// The identifier used to distinguish between accounts.
+	type AccountId = AccountId;
+	/// The aggregated dispatch type that is available for extrinsics.
+	type Call = Call;
+	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.
+	type Lookup = IdentityLookup<AccountId>;
+	/// The index type for storing how many extrinsics an account has signed.
+	type Index = Index;
+	/// The index type for blocks.
+	type BlockNumber = BlockNumber;
+	/// The type for hashing blocks and tries.
+	type Hash = Hash;
+	/// The hashing algorithm used.
+	type Hashing = Hashing;
+	/// The header type.
+	type Header = generic::Header<BlockNumber, Hashing>;
+	/// The ubiquitous event type.
+	type Event = Event;
+	/// The ubiquitous origin type.
+	type Origin = Origin;
+	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
+	type BlockHashCount = BlockHashCount;
+	/// Version of the runtime.
+	type Version = Version;
+	/// Provides information about the pallet setup in the runtime.
+	type PalletInfo = PalletInfo;
+	/// What to do if a new account is created.
+	type OnNewAccount = ();
+	/// What to do if an account is fully reaped from the system.
+	type OnKilledAccount = ();
+	/// The data to be stored in an account.
+	type AccountData = pallet_balances::AccountData<Balance>;
+	// TODO: update me (https://github.com/paritytech/parity-bridges-common/issues/78)
+	/// Weight information for the extrinsics of this pallet.
+	type SystemWeightInfo = ();
+	/// Block and extrinsics weights: base values and limits.
+	type BlockWeights = bp_millau::BlockWeights;
+	/// The maximum length of a block (in bytes).
+	type BlockLength = bp_millau::BlockLength;
+	/// The weight of database operations that the runtime can invoke.
+	type DbWeight = DbWeight;
+	/// The designated SS58 prefix of this chain.
+	type SS58Prefix = SS58Prefix;
+}
+
+impl pallet_aura::Config for Runtime {
+	type AuthorityId = AuraId;
+}
+impl pallet_bridge_call_dispatch::Config for Runtime {
+	type Event = Event;
+	type MessageId = (bp_message_lane::LaneId, bp_message_lane::MessageNonce);
+	type Call = Call;
+	type CallFilter = ();
+	type EncodedCall = crate::rialto_messages::FromRialtoEncodedCall;
+	type SourceChainAccountId = bp_rialto::AccountId;
+	type TargetChainAccountPublic = MultiSigner;
+	type TargetChainSignature = MultiSignature;
+	type AccountIdConverter = bp_millau::AccountIdConverter;
+}
+
+impl pallet_grandpa::Config for Runtime {
+	type Event = Event;
+	type Call = Call;
+	type KeyOwnerProofSystem = ();
+	type KeyOwnerProof = <Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof;
+	type KeyOwnerIdentification =
+		<Self::KeyOwnerProofSystem as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::IdentificationTuple;
+	type HandleEquivocation = ();
+	// TODO: update me (https://github.com/paritytech/parity-bridges-common/issues/78)
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub const MinimumPeriod: u64 = bp_millau::SLOT_DURATION / 2;
+}
+
+impl pallet_timestamp::Config for Runtime {
+	/// A timestamp: milliseconds since the unix epoch.
+	type Moment = u64;
+	type OnTimestampSet = Aura;
+	type MinimumPeriod = MinimumPeriod;
+	// TODO: update me (https://github.com/paritytech/parity-bridges-common/issues/78)
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub const ExistentialDeposit: bp_millau::Balance = 500;
+	// For weight estimation, we assume that the most locks on an individual account will be 50.
+	// This number may need to be adjusted in the future if this assumption no longer holds true.
+	pub const MaxLocks: u32 = 50;
+}
+
+impl pallet_balances::Config for Runtime {
+	/// The type for recording an account's balance.
+	type Balance = Balance;
+	/// The ubiquitous event type.
+	type Event = Event;
+	type DustRemoval = ();
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	// TODO: update me (https://github.com/paritytech/parity-bridges-common/issues/78)
+	type WeightInfo = ();
+	type MaxLocks = MaxLocks;
+}
+
+parameter_types! {
+	pub const TransactionBaseFee: Balance = 0;
+	pub const TransactionByteFee: Balance = 1;
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+	type OnChargeTransaction = pallet_transaction_payment::CurrencyAdapter<Balances, ()>;
+	type TransactionByteFee = TransactionByteFee;
+	type WeightToFee = IdentityFee<Balance>;
+	type FeeMultiplierUpdate = ();
+}
+
+impl pallet_sudo::Config for Runtime {
+	type Event = Event;
+	type Call = Call;
+}
+
+parameter_types! {
+	/// Authorities are changing every 5 minutes.
+	pub const Period: BlockNumber = bp_millau::SESSION_LENGTH;
+	pub const Offset: BlockNumber = 0;
+}
+
+impl pallet_session::Config for Runtime {
+	type Event = Event;
+	type ValidatorId = <Self as frame_system::Config>::AccountId;
+	type ValidatorIdOf = ();
+	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type SessionManager = pallet_shift_session_manager::Module<Runtime>;
+	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+	type Keys = SessionKeys;
+	type DisabledValidatorsThreshold = ();
+	// TODO: update me (https://github.com/paritytech/parity-bridges-common/issues/78)
+	type WeightInfo = ();
+}
+
+impl pallet_substrate_bridge::Config for Runtime {
+	type BridgedChain = bp_rialto::Rialto;
+}
+
+parameter_types! {
+	// This is a pretty unscientific cap.
+	//
+	// Note that once this is hit the pallet will essentially throttle incoming requests down to one
+	// call per block.
+	pub const MaxRequests: u32 = 50;
+}
+
+impl pallet_finality_verifier::Config for Runtime {
+	type BridgedChain = bp_rialto::Rialto;
+	type HeaderChain = pallet_substrate_bridge::Module<Runtime>;
+	type AncestryProof = Vec<bp_rialto::Header>;
+	type AncestryChecker = bp_header_chain::LinearAncestryChecker;
+	type MaxRequests = MaxRequests;
+}
+
+impl pallet_shift_session_manager::Config for Runtime {}
+
+parameter_types! {
+	pub const MaxMessagesToPruneAtOnce: bp_message_lane::MessageNonce = 8;
+	pub const MaxUnrewardedRelayerEntriesAtInboundLane: bp_message_lane::MessageNonce =
+		bp_millau::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE;
+	pub const MaxUnconfirmedMessagesAtInboundLane: bp_message_lane::MessageNonce =
+		bp_millau::MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE;
+	// `IdentityFee` is used by Millau => we may use weight directly
+	pub const GetDeliveryConfirmationTransactionFee: Balance =
+		bp_millau::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT as _;
+	pub const RootAccountForPayments: Option<AccountId> = None;
+}
+
+impl pallet_message_lane::Config for Runtime {
+	type Event = Event;
+	// TODO: https://github.com/paritytech/parity-bridges-common/issues/390
+	type WeightInfo = pallet_message_lane::weights::RialtoWeight<Runtime>;
+	type Parameter = rialto_messages::MillauToRialtoMessageLaneParameter;
+	type MaxMessagesToPruneAtOnce = MaxMessagesToPruneAtOnce;
+	type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane;
+	type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane;
+
+	type OutboundPayload = crate::rialto_messages::ToRialtoMessagePayload;
+	type OutboundMessageFee = Balance;
+
+	type InboundPayload = crate::rialto_messages::FromRialtoMessagePayload;
+	type InboundMessageFee = bp_rialto::Balance;
+	type InboundRelayer = bp_rialto::AccountId;
+
+	type AccountIdConverter = bp_millau::AccountIdConverter;
+
+	type TargetHeaderChain = crate::rialto_messages::Rialto;
+	type LaneMessageVerifier = crate::rialto_messages::ToRialtoMessageVerifier;
+	type MessageDeliveryAndDispatchPayment = pallet_message_lane::instant_payments::InstantCurrencyPayments<
+		Runtime,
+		pallet_balances::Module<Runtime>,
+		GetDeliveryConfirmationTransactionFee,
+		RootAccountForPayments,
+	>;
+
+	type SourceHeaderChain = crate::rialto_messages::Rialto;
+	type MessageDispatch = crate::rialto_messages::FromRialtoMessageDispatch;
+}
+
+construct_runtime!(
+	pub enum Runtime where
+		Block = Block,
+		NodeBlock = opaque::Block,
+		UncheckedExtrinsic = UncheckedExtrinsic
+	{
+		BridgeRialto: pallet_substrate_bridge::{Module, Call, Storage, Config<T>},
+		BridgeRialtoMessageLane: pallet_message_lane::{Module, Call, Storage, Event<T>},
+		BridgeCallDispatch: pallet_bridge_call_dispatch::{Module, Event<T>},
+		BridgeFinalityVerifier: pallet_finality_verifier::{Module, Call},
+		System: frame_system::{Module, Call, Config, Storage, Event<T>},
+		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Call, Storage},
+		Timestamp: pallet_timestamp::{Module, Call, Storage, Inherent},
+		Aura: pallet_aura::{Module, Config<T>},
+		Grandpa: pallet_grandpa::{Module, Call, Storage, Config, Event},
+		Balances: pallet_balances::{Module, Call, Storage, Config<T>, Event<T>},
+		TransactionPayment: pallet_transaction_payment::{Module, Storage},
+		Sudo: pallet_sudo::{Module, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Module, Call, Storage, Event, Config<T>},
+		ShiftSessionManager: pallet_shift_session_manager::{Module},
+	}
+);
+
+/// The address format for describing accounts.
+pub type Address = AccountId;
+/// Block header type as expected by this runtime.
+pub type Header = generic::Header<BlockNumber, Hashing>;
+/// Block type as expected by this runtime.
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+/// A Block signed with a Justification
+pub type SignedBlock = generic::SignedBlock<Block>;
+/// BlockId type as expected by this runtime.
+pub type BlockId = generic::BlockId<Block>;
+/// The SignedExtension to the basic transaction logic.
+pub type SignedExtra = (
+	frame_system::CheckSpecVersion<Runtime>,
+	frame_system::CheckTxVersion<Runtime>,
+	frame_system::CheckGenesis<Runtime>,
+	frame_system::CheckEra<Runtime>,
+	frame_system::CheckNonce<Runtime>,
+	frame_system::CheckWeight<Runtime>,
+	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+);
+/// The payload being signed in transactions.
+pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
+/// Unchecked extrinsic type as expected by this runtime.
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
+/// Extrinsic type that has already been checked.
+pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;
+/// Executive: handles dispatch to the various modules.
+pub type Executive =
+	frame_executive::Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllModules>;
+
+impl_runtime_apis! {
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion {
+			VERSION
+		}
+
+		fn execute_block(block: Block) {
+			Executive::execute_block(block)
+		}
+
+		fn initialize_block(header: &<Block as BlockT>::Header) {
+			Executive::initialize_block(header)
+		}
+	}
+
+	impl sp_api::Metadata<Block> for Runtime {
+		fn metadata() -> OpaqueMetadata {
+			Runtime::metadata().into()
+		}
+	}
+
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
+		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
+			Executive::apply_extrinsic(extrinsic)
+		}
+
+		fn finalize_block() -> <Block as BlockT>::Header {
+			Executive::finalize_block()
+		}
+
+		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+			data.create_extrinsics()
+		}
+
+		fn check_inherents(
+			block: Block,
+			data: sp_inherents::InherentData,
+		) -> sp_inherents::CheckInherentsResult {
+			data.check_extrinsics(&block)
+		}
+
+		fn random_seed() -> <Block as BlockT>::Hash {
+			RandomnessCollectiveFlip::random_seed()
+		}
+	}
+
+	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {
+		fn account_nonce(account: AccountId) -> Index {
+			System::account_nonce(account)
+		}
+	}
+
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+		fn validate_transaction(
+			source: TransactionSource,
+			tx: <Block as BlockT>::Extrinsic,
+		) -> TransactionValidity {
+			Executive::validate_transaction(source, tx)
+		}
+	}
+
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
+		fn offchain_worker(header: &<Block as BlockT>::Header) {
+			Executive::offchain_worker(header)
+		}
+	}
+
+	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
+		fn slot_duration() -> u64 {
+			Aura::slot_duration()
+		}
+
+		fn authorities() -> Vec<AuraId> {
+			Aura::authorities()
+		}
+	}
+
+	impl sp_session::SessionKeys<Block> for Runtime {
+		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
+			SessionKeys::generate(seed)
+		}
+
+		fn decode_session_keys(
+			encoded: Vec<u8>,
+		) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {
+			SessionKeys::decode_into_raw_public_keys(&encoded)
+		}
+	}
+
+	impl fg_primitives::GrandpaApi<Block> for Runtime {
+		fn grandpa_authorities() -> GrandpaAuthorityList {
+			Grandpa::grandpa_authorities()
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			equivocation_proof: fg_primitives::EquivocationProof<
+				<Block as BlockT>::Hash,
+				NumberFor<Block>,
+			>,
+			key_owner_proof: fg_primitives::OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			let key_owner_proof = key_owner_proof.decode()?;
+
+			Grandpa::submit_unsigned_equivocation_report(
+				equivocation_proof,
+				key_owner_proof,
+			)
+		}
+
+		fn generate_key_ownership_proof(
+			_set_id: fg_primitives::SetId,
+			_authority_id: GrandpaId,
+		) -> Option<fg_primitives::OpaqueKeyOwnershipProof> {
+			// NOTE: this is the only implementation possible since we've
+			// defined our key owner proof type as a bottom type (i.e. a type
+			// with no values).
+			None
+		}
+	}
+
+	impl bp_rialto::RialtoHeaderApi<Block> for Runtime {
+		fn best_blocks() -> Vec<(bp_rialto::BlockNumber, bp_rialto::Hash)> {
+			BridgeRialto::best_headers()
+		}
+
+		fn finalized_block() -> (bp_rialto::BlockNumber, bp_rialto::Hash) {
+			let header = BridgeRialto::best_finalized();
+			(header.number, header.hash())
+		}
+
+		fn incomplete_headers() -> Vec<(bp_rialto::BlockNumber, bp_rialto::Hash)> {
+			BridgeRialto::require_justifications()
+		}
+
+		fn is_known_block(hash: bp_rialto::Hash) -> bool {
+			BridgeRialto::is_known_header(hash)
+		}
+
+		fn is_finalized_block(hash: bp_rialto::Hash) -> bool {
+			BridgeRialto::is_finalized_header(hash)
+		}
+	}
+
+	impl bp_rialto::ToRialtoOutboundLaneApi<Block, Balance, ToRialtoMessagePayload> for Runtime {
+		fn estimate_message_delivery_and_dispatch_fee(
+			_lane_id: bp_message_lane::LaneId,
+			payload: ToRialtoMessagePayload,
+		) -> Option<Balance> {
+			estimate_message_dispatch_and_delivery_fee::<WithRialtoMessageBridge>(
+				&payload,
+				WithRialtoMessageBridge::RELAYER_FEE_PERCENT,
+			).ok()
+		}
+
+		fn messages_dispatch_weight(
+			lane: bp_message_lane::LaneId,
+			begin: bp_message_lane::MessageNonce,
+			end: bp_message_lane::MessageNonce,
+		) -> Vec<(bp_message_lane::MessageNonce, Weight, u32)> {
+			(begin..=end).filter_map(|nonce| {
+				let encoded_payload = BridgeRialtoMessageLane::outbound_message_payload(lane, nonce)?;
+				let decoded_payload = rialto_messages::ToRialtoMessagePayload::decode(
+					&mut &encoded_payload[..]
+				).ok()?;
+				Some((nonce, decoded_payload.weight, encoded_payload.len() as _))
+			})
+			.collect()
+		}
+
+		fn latest_received_nonce(lane: bp_message_lane::LaneId) -> bp_message_lane::MessageNonce {
+			BridgeRialtoMessageLane::outbound_latest_received_nonce(lane)
+		}
+
+		fn latest_generated_nonce(lane: bp_message_lane::LaneId) -> bp_message_lane::MessageNonce {
+			BridgeRialtoMessageLane::outbound_latest_generated_nonce(lane)
+		}
+	}
+
+	impl bp_rialto::FromRialtoInboundLaneApi<Block> for Runtime {
+		fn latest_received_nonce(lane: bp_message_lane::LaneId) -> bp_message_lane::MessageNonce {
+			BridgeRialtoMessageLane::inbound_latest_received_nonce(lane)
+		}
+
+		fn latest_confirmed_nonce(lane: bp_message_lane::LaneId) -> bp_message_lane::MessageNonce {
+			BridgeRialtoMessageLane::inbound_latest_confirmed_nonce(lane)
+		}
+
+		fn unrewarded_relayers_state(lane: bp_message_lane::LaneId) -> bp_message_lane::UnrewardedRelayersState {
+			BridgeRialtoMessageLane::inbound_unrewarded_relayers_state(lane)
+		}
+	}
+}
+
+/// Rialto account ownership digest from Millau.
+///
+/// The byte vector returned by this function should be signed with a Rialto account private key.
+/// This way, the owner of `millau_account_id` on Millau proves that the Rialto account private key
+/// is also under his control.
+pub fn rialto_account_ownership_digest<Call, AccountId, SpecVersion>(
+	rialto_call: &Call,
+	millau_account_id: AccountId,
+	rialto_spec_version: SpecVersion,
+) -> sp_std::vec::Vec<u8>
+where
+	Call: codec::Encode,
+	AccountId: codec::Encode,
+	SpecVersion: codec::Encode,
+{
+	pallet_bridge_call_dispatch::account_ownership_digest(
+		rialto_call,
+		millau_account_id,
+		rialto_spec_version,
+		bp_runtime::MILLAU_BRIDGE_INSTANCE,
+	)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use bridge_runtime_common::messages;
+
+	#[test]
+	fn ensure_millau_message_lane_weights_are_correct() {
+		// TODO: https://github.com/paritytech/parity-bridges-common/issues/390
+		type Weights = pallet_message_lane::weights::RialtoWeight<Runtime>;
+
+		pallet_message_lane::ensure_weights_are_correct::<Weights>(
+			bp_millau::DEFAULT_MESSAGE_DELIVERY_TX_WEIGHT,
+			bp_millau::ADDITIONAL_MESSAGE_BYTE_DELIVERY_WEIGHT,
+			bp_millau::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT,
+		);
+
+		let max_incoming_message_proof_size = bp_rialto::EXTRA_STORAGE_PROOF_SIZE.saturating_add(
+			messages::target::maximal_incoming_message_size(bp_millau::max_extrinsic_size()),
+		);
+		pallet_message_lane::ensure_able_to_receive_message::<Weights>(
+			bp_millau::max_extrinsic_size(),
+			bp_millau::max_extrinsic_weight(),
+			max_incoming_message_proof_size,
+			bridge_runtime_common::messages::transaction_weight_without_multiplier(
+				bp_millau::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
+				max_incoming_message_proof_size as _,
+				0,
+			),
+			messages::target::maximal_incoming_message_dispatch_weight(bp_millau::max_extrinsic_weight()),
+		);
+
+		let max_incoming_inbound_lane_data_proof_size = bp_message_lane::InboundLaneData::<()>::encoded_size_hint(
+			bp_millau::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE,
+			bp_rialto::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE as _,
+		)
+		.unwrap_or(u32::MAX);
+		pallet_message_lane::ensure_able_to_receive_confirmation::<Weights>(
+			bp_millau::max_extrinsic_size(),
+			bp_millau::max_extrinsic_weight(),
+			max_incoming_inbound_lane_data_proof_size,
+			bp_rialto::MAX_UNREWARDED_RELAYER_ENTRIES_AT_INBOUND_LANE,
+			bp_rialto::MAX_UNCONFIRMED_MESSAGES_AT_INBOUND_LANE,
+			bridge_runtime_common::messages::transaction_weight_without_multiplier(
+				bp_millau::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
+				max_incoming_inbound_lane_data_proof_size as _,
+				0,
+			),
+		);
+	}
+}

polkadot/bridges/bin/millau/runtime/src/rialto_messages.rs

@@ -0,0 +1,254 @@
+// Copyright 2019-2020 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/>.
+
+//! Everything required to serve Millau <-> Rialto message lanes.
+
+use crate::Runtime;
+
+use bp_message_lane::{
+	source_chain::TargetHeaderChain,
+	target_chain::{ProvedMessages, SourceHeaderChain},
+	InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessageLaneParameter,
+};
+use bp_runtime::{InstanceId, RIALTO_BRIDGE_INSTANCE};
+use bridge_runtime_common::messages::{self, ChainWithMessageLanes, MessageBridge};
+use codec::{Decode, Encode};
+use frame_support::{
+	parameter_types,
+	weights::{DispatchClass, Weight, WeightToFeePolynomial},
+	RuntimeDebug,
+};
+use sp_core::storage::StorageKey;
+use sp_runtime::{FixedPointNumber, FixedU128};
+use sp_std::{convert::TryFrom, ops::RangeInclusive};
+
+parameter_types! {
+	/// Rialto to Millau conversion rate. Initially we treat both tokens as equal.
+	storage RialtoToMillauConversionRate: FixedU128 = 1.into();
+}
+
+/// Storage key of the Millau -> Rialto message in the runtime storage.
+pub fn message_key(lane: &LaneId, nonce: MessageNonce) -> StorageKey {
+	pallet_message_lane::storage_keys::message_key::<Runtime, <Millau as ChainWithMessageLanes>::MessageLaneInstance>(
+		lane, nonce,
+	)
+}
+
+/// Storage key of the Millau -> Rialto message lane state in the runtime storage.
+pub fn outbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	pallet_message_lane::storage_keys::outbound_lane_data_key::<<Millau as ChainWithMessageLanes>::MessageLaneInstance>(
+		lane,
+	)
+}
+
+/// Storage key of the Rialto -> Millau message lane state in the runtime storage.
+pub fn inbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	pallet_message_lane::storage_keys::inbound_lane_data_key::<
+		Runtime,
+		<Millau as ChainWithMessageLanes>::MessageLaneInstance,
+	>(lane)
+}
+
+/// Message payload for Millau -> Rialto messages.
+pub type ToRialtoMessagePayload = messages::source::FromThisChainMessagePayload<WithRialtoMessageBridge>;
+
+/// Message verifier for Millau -> Rialto messages.
+pub type ToRialtoMessageVerifier = messages::source::FromThisChainMessageVerifier<WithRialtoMessageBridge>;
+
+/// Message payload for Rialto -> Millau messages.
+pub type FromRialtoMessagePayload = messages::target::FromBridgedChainMessagePayload<WithRialtoMessageBridge>;
+
+/// Encoded Millau Call as it comes from Rialto.
+pub type FromRialtoEncodedCall = messages::target::FromBridgedChainEncodedMessageCall<WithRialtoMessageBridge>;
+
+/// Messages proof for Rialto -> Millau messages.
+type FromRialtoMessagesProof = messages::target::FromBridgedChainMessagesProof<bp_rialto::Hash>;
+
+/// Messages delivery proof for Millau -> Rialto messages.
+type ToRialtoMessagesDeliveryProof = messages::source::FromBridgedChainMessagesDeliveryProof<bp_rialto::Hash>;
+
+/// Call-dispatch based message dispatch for Rialto -> Millau messages.
+pub type FromRialtoMessageDispatch = messages::target::FromBridgedChainMessageDispatch<
+	WithRialtoMessageBridge,
+	crate::Runtime,
+	pallet_bridge_call_dispatch::DefaultInstance,
+>;
+
+/// Millau <-> Rialto message bridge.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct WithRialtoMessageBridge;
+
+impl MessageBridge for WithRialtoMessageBridge {
+	const INSTANCE: InstanceId = RIALTO_BRIDGE_INSTANCE;
+
+	const RELAYER_FEE_PERCENT: u32 = 10;
+
+	type ThisChain = Millau;
+	type BridgedChain = Rialto;
+
+	fn maximal_extrinsic_size_on_target_chain() -> u32 {
+		bp_rialto::max_extrinsic_size()
+	}
+
+	fn weight_limits_of_message_on_bridged_chain(_message_payload: &[u8]) -> RangeInclusive<Weight> {
+		// we don't want to relay too large messages + keep reserve for future upgrades
+		let upper_limit = messages::target::maximal_incoming_message_dispatch_weight(bp_rialto::max_extrinsic_weight());
+
+		// we're charging for payload bytes in `WithRialtoMessageBridge::weight_of_delivery_transaction` function
+		//
+		// this bridge may be used to deliver all kind of messages, so we're not making any assumptions about
+		// minimal dispatch weight here
+
+		0..=upper_limit
+	}
+
+	fn weight_of_delivery_transaction(message_payload: &[u8]) -> Weight {
+		let message_payload_len = u32::try_from(message_payload.len())
+			.map(Into::into)
+			.unwrap_or(Weight::MAX);
+		let extra_bytes_in_payload =
+			message_payload_len.saturating_sub(pallet_message_lane::EXPECTED_DEFAULT_MESSAGE_LENGTH.into());
+		messages::transaction_weight_without_multiplier(
+			bp_rialto::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
+			message_payload_len.saturating_add(bp_millau::EXTRA_STORAGE_PROOF_SIZE as _),
+			extra_bytes_in_payload
+				.saturating_mul(bp_rialto::ADDITIONAL_MESSAGE_BYTE_DELIVERY_WEIGHT)
+				.saturating_add(bp_rialto::DEFAULT_MESSAGE_DELIVERY_TX_WEIGHT),
+		)
+	}
+
+	fn weight_of_delivery_confirmation_transaction_on_this_chain() -> Weight {
+		let inbounded_data_size: Weight =
+			InboundLaneData::<bp_rialto::AccountId>::encoded_size_hint(bp_rialto::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE, 1)
+				.map(Into::into)
+				.unwrap_or(Weight::MAX);
+
+		messages::transaction_weight_without_multiplier(
+			bp_millau::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
+			inbounded_data_size.saturating_add(bp_rialto::EXTRA_STORAGE_PROOF_SIZE as _),
+			bp_millau::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT,
+		)
+	}
+
+	fn this_weight_to_this_balance(weight: Weight) -> bp_millau::Balance {
+		<crate::Runtime as pallet_transaction_payment::Config>::WeightToFee::calc(&weight)
+	}
+
+	fn bridged_weight_to_bridged_balance(weight: Weight) -> bp_rialto::Balance {
+		// we're using the same weights in both chains now
+		<crate::Runtime as pallet_transaction_payment::Config>::WeightToFee::calc(&weight) as _
+	}
+
+	fn bridged_balance_to_this_balance(bridged_balance: bp_rialto::Balance) -> bp_millau::Balance {
+		bp_millau::Balance::try_from(RialtoToMillauConversionRate::get().saturating_mul_int(bridged_balance))
+			.unwrap_or(bp_millau::Balance::MAX)
+	}
+}
+
+/// Millau chain from message lane point of view.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct Millau;
+
+impl messages::ChainWithMessageLanes for Millau {
+	type Hash = bp_millau::Hash;
+	type AccountId = bp_millau::AccountId;
+	type Signer = bp_millau::AccountSigner;
+	type Signature = bp_millau::Signature;
+	type Call = crate::Call;
+	type Weight = Weight;
+	type Balance = bp_millau::Balance;
+
+	type MessageLaneInstance = pallet_message_lane::DefaultInstance;
+}
+
+impl messages::ThisChainWithMessageLanes for Millau {
+	fn is_outbound_lane_enabled(lane: &LaneId) -> bool {
+		*lane == LaneId::default()
+	}
+
+	fn maximal_pending_messages_at_outbound_lane() -> MessageNonce {
+		MessageNonce::MAX
+	}
+}
+
+/// Rialto chain from message lane point of view.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct Rialto;
+
+impl messages::ChainWithMessageLanes for Rialto {
+	type Hash = bp_rialto::Hash;
+	type AccountId = bp_rialto::AccountId;
+	type Signer = bp_rialto::AccountSigner;
+	type Signature = bp_rialto::Signature;
+	type Call = (); // unknown to us
+	type Weight = Weight;
+	type Balance = bp_rialto::Balance;
+
+	type MessageLaneInstance = pallet_message_lane::DefaultInstance;
+}
+
+impl TargetHeaderChain<ToRialtoMessagePayload, bp_rialto::AccountId> for Rialto {
+	type Error = &'static str;
+	// The proof is:
+	// - hash of the header this proof has been created with;
+	// - the storage proof or one or several keys;
+	// - id of the lane we prove state of.
+	type MessagesDeliveryProof = ToRialtoMessagesDeliveryProof;
+
+	fn verify_message(payload: &ToRialtoMessagePayload) -> Result<(), Self::Error> {
+		messages::source::verify_chain_message::<WithRialtoMessageBridge>(payload)
+	}
+
+	fn verify_messages_delivery_proof(
+		proof: Self::MessagesDeliveryProof,
+	) -> Result<(LaneId, InboundLaneData<bp_millau::AccountId>), Self::Error> {
+		messages::source::verify_messages_delivery_proof::<WithRialtoMessageBridge, Runtime>(proof)
+	}
+}
+
+impl SourceHeaderChain<bp_rialto::Balance> for Rialto {
+	type Error = &'static str;
+	// The proof is:
+	// - hash of the header this proof has been created with;
+	// - the storage proof or one or several keys;
+	// - id of the lane we prove messages for;
+	// - inclusive range of messages nonces that are proved.
+	type MessagesProof = FromRialtoMessagesProof;
+
+	fn verify_messages_proof(
+		proof: Self::MessagesProof,
+		messages_count: u32,
+	) -> Result<ProvedMessages<Message<bp_rialto::Balance>>, Self::Error> {
+		messages::target::verify_messages_proof::<WithRialtoMessageBridge, Runtime>(proof, messages_count)
+	}
+}
+
+/// Millau -> Rialto message lane pallet parameters.
+#[derive(RuntimeDebug, Clone, Encode, Decode, PartialEq, Eq)]
+pub enum MillauToRialtoMessageLaneParameter {
+	/// The conversion formula we use is: `MillauTokens = RialtoTokens * conversion_rate`.
+	RialtoToMillauConversionRate(FixedU128),
+}
+
+impl MessageLaneParameter for MillauToRialtoMessageLaneParameter {
+	fn save(&self) {
+		match *self {
+			MillauToRialtoMessageLaneParameter::RialtoToMillauConversionRate(ref conversion_rate) => {
+				RialtoToMillauConversionRate::set(conversion_rate)
+			}
+		}
+	}
+}

polkadot/bridges/bin/rialto/node/Cargo.toml

@@ -0,0 +1,59 @@
+[package]
+name = "rialto-bridge-node"
+description = "Substrate node compatible with Rialto runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+build = "build.rs"
+homepage = "https://substrate.dev"
+repository = "https://github.com/paritytech/parity-bridges-common/"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+jsonrpc-core = "15.1.0"
+structopt = "0.3.21"
+
+# Bridge dependencies
+
+bp-message-lane = { path = "../../../primitives/message-lane" }
+bp-runtime = { path = "../../../primitives/runtime" }
+bp-rialto = { path = "../../../primitives/rialto" }
+pallet-message-lane = { path = "../../../modules/message-lane" }
+pallet-message-lane-rpc = { path = "../../../modules/message-lane/rpc" }
+rialto-runtime = { path = "../runtime" }
+
+# Substrate Dependencies
+
+frame-benchmarking = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+frame-benchmarking-cli = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-basic-authorship = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-cli = { git = "https://github.com/paritytech/substrate.git", branch = "master", features = ["wasmtime"] }
+sc-client-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-consensus = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-consensus-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-executor = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-finality-grandpa-rpc = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-keystore = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-service = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-rpc = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-transaction-pool = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sc-telemetry = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-consensus = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-consensus-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-core = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-inherents = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+sp-runtime = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+substrate-frame-rpc-system = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+
+[build-dependencies]
+build-script-utils = { package = "substrate-build-script-utils", version = "2.0" }
+frame-benchmarking-cli = { git = "https://github.com/paritytech/substrate.git", branch = "master" }
+vergen = "3.1.0"
+
+[features]
+default = []
+runtime-benchmarks = [
+	"rialto-runtime/runtime-benchmarks",
+]

polkadot/bridges/bin/rialto/node/build.rs

@@ -0,0 +1,25 @@
+// Copyright 2019-2020 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 vergen::{generate_cargo_keys, ConstantsFlags};
+
+const ERROR_MSG: &str = "Failed to generate metadata files";
+
+fn main() {
+	generate_cargo_keys(ConstantsFlags::SHA_SHORT).expect(ERROR_MSG);
+
+	build_script_utils::rerun_if_git_head_changed();
+}

polkadot/bridges/bin/rialto/node/src/chain_spec.rs

@@ -0,0 +1,208 @@
+// Copyright 2019-2020 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 bp_rialto::derive_account_from_millau_id;
+use rialto_runtime::{
+	AccountId, AuraConfig, BalancesConfig, BridgeKovanConfig, BridgeMillauConfig, BridgeRialtoPoAConfig, GenesisConfig,
+	GrandpaConfig, SessionConfig, SessionKeys, Signature, SudoConfig, SystemConfig, WASM_BINARY,
+};
+use sp_consensus_aura::sr25519::AuthorityId as AuraId;
+use sp_core::{sr25519, Pair, Public};
+use sp_finality_grandpa::AuthorityId as GrandpaId;
+use sp_runtime::traits::{IdentifyAccount, Verify};
+
+/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
+pub type ChainSpec = sc_service::GenericChainSpec<GenesisConfig>;
+
+/// The chain specification option. This is expected to come in from the CLI and
+/// is little more than one of a number of alternatives which can easily be converted
+/// from a string (`--chain=...`) into a `ChainSpec`.
+#[derive(Clone, Debug)]
+pub enum Alternative {
+	/// Whatever the current runtime is, with just Alice as an auth.
+	Development,
+	/// Whatever the current runtime is, with simple Alice/Bob/Charlie/Dave/Eve auths.
+	LocalTestnet,
+}
+
+/// Helper function to generate a crypto pair from seed
+pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
+		.expect("static values are valid; qed")
+		.public()
+}
+
+type AccountPublic = <Signature as Verify>::Signer;
+
+/// Helper function to generate an account ID from seed
+pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
+where
+	AccountPublic: From<<TPublic::Pair as Pair>::Public>,
+{
+	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
+}
+
+/// Helper function to generate an authority key for Aura
+pub fn get_authority_keys_from_seed(s: &str) -> (AccountId, AuraId, GrandpaId) {
+	(
+		get_account_id_from_seed::<sr25519::Public>(s),
+		get_from_seed::<AuraId>(s),
+		get_from_seed::<GrandpaId>(s),
+	)
+}
+
+impl Alternative {
+	/// Get an actual chain config from one of the alternatives.
+	pub(crate) fn load(self) -> ChainSpec {
+		match self {
+			Alternative::Development => ChainSpec::from_genesis(
+				"Development",
+				"dev",
+				sc_service::ChainType::Development,
+				|| {
+					testnet_genesis(
+						vec![get_authority_keys_from_seed("Alice")],
+						get_account_id_from_seed::<sr25519::Public>("Alice"),
+						vec![
+							get_account_id_from_seed::<sr25519::Public>("Alice"),
+							get_account_id_from_seed::<sr25519::Public>("Bob"),
+							get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+						],
+						true,
+					)
+				},
+				vec![],
+				None,
+				None,
+				None,
+				None,
+			),
+			Alternative::LocalTestnet => ChainSpec::from_genesis(
+				"Local Testnet",
+				"local_testnet",
+				sc_service::ChainType::Local,
+				|| {
+					testnet_genesis(
+						vec![
+							get_authority_keys_from_seed("Alice"),
+							get_authority_keys_from_seed("Bob"),
+							get_authority_keys_from_seed("Charlie"),
+							get_authority_keys_from_seed("Dave"),
+							get_authority_keys_from_seed("Eve"),
+						],
+						get_account_id_from_seed::<sr25519::Public>("Alice"),
+						vec![
+							get_account_id_from_seed::<sr25519::Public>("Alice"),
+							get_account_id_from_seed::<sr25519::Public>("Bob"),
+							get_account_id_from_seed::<sr25519::Public>("Charlie"),
+							get_account_id_from_seed::<sr25519::Public>("Dave"),
+							get_account_id_from_seed::<sr25519::Public>("Eve"),
+							get_account_id_from_seed::<sr25519::Public>("Ferdie"),
+							get_account_id_from_seed::<sr25519::Public>("George"),
+							get_account_id_from_seed::<sr25519::Public>("Harry"),
+							get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
+							get_account_id_from_seed::<sr25519::Public>("George//stash"),
+							get_account_id_from_seed::<sr25519::Public>("Harry//stash"),
+							pallet_message_lane::Module::<rialto_runtime::Runtime, pallet_message_lane::DefaultInstance>::relayer_fund_account_id(),
+							derive_account_from_millau_id(bp_runtime::SourceAccount::Account(
+								get_account_id_from_seed::<sr25519::Public>("Dave"),
+							)),
+						],
+						true,
+					)
+				},
+				vec![],
+				None,
+				None,
+				None,
+				None,
+			),
+		}
+	}
+}
+
+fn session_keys(aura: AuraId, grandpa: GrandpaId) -> SessionKeys {
+	SessionKeys { aura, grandpa }
+}
+
+fn testnet_genesis(
+	initial_authorities: Vec<(AccountId, AuraId, GrandpaId)>,
+	root_key: AccountId,
+	endowed_accounts: Vec<AccountId>,
+	_enable_println: bool,
+) -> GenesisConfig {
+	GenesisConfig {
+		frame_system: Some(SystemConfig {
+			code: WASM_BINARY.to_vec(),
+			changes_trie_config: Default::default(),
+		}),
+		pallet_balances: Some(BalancesConfig {
+			balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 50)).collect(),
+		}),
+		pallet_aura: Some(AuraConfig {
+			authorities: Vec::new(),
+		}),
+		pallet_bridge_eth_poa_Instance1: Some(load_rialto_poa_bridge_config()),
+		pallet_bridge_eth_poa_Instance2: Some(load_kovan_bridge_config()),
+		pallet_grandpa: Some(GrandpaConfig {
+			authorities: Vec::new(),
+		}),
+		pallet_substrate_bridge: Some(BridgeMillauConfig {
+			// We'll initialize the pallet with a dispatchable instead.
+			init_data: None,
+			owner: Some(root_key.clone()),
+		}),
+		pallet_sudo: Some(SudoConfig { key: root_key }),
+		pallet_session: Some(SessionConfig {
+			keys: initial_authorities
+				.iter()
+				.map(|x| (x.0.clone(), x.0.clone(), session_keys(x.1.clone(), x.2.clone())))
+				.collect::<Vec<_>>(),
+		}),
+	}
+}
+
+fn load_rialto_poa_bridge_config() -> BridgeRialtoPoAConfig {
+	BridgeRialtoPoAConfig {
+		initial_header: rialto_runtime::rialto_poa::genesis_header(),
+		initial_difficulty: 0.into(),
+		initial_validators: rialto_runtime::rialto_poa::genesis_validators(),
+	}
+}
+
+fn load_kovan_bridge_config() -> BridgeKovanConfig {
+	BridgeKovanConfig {
+		initial_header: rialto_runtime::kovan::genesis_header(),
+		initial_difficulty: 0.into(),
+		initial_validators: rialto_runtime::kovan::genesis_validators(),
+	}
+}
+
+#[test]
+fn derived_dave_account_is_as_expected() {
+	let dave = get_account_id_from_seed::<sr25519::Public>("Dave");
+	let derived: AccountId = derive_account_from_millau_id(bp_runtime::SourceAccount::Account(dave));
+	assert_eq!(
+		derived.to_string(),
+		"5HZhdv53gSJmWWtD8XR5Ypu4PgbT5JNWwGw2mkE75cN61w9t".to_string()
+	);
+}

polkadot/bridges/bin/rialto/node/src/cli.rs

@@ -0,0 +1,67 @@
+// Copyright 2019-2020 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 sc_cli::RunCmd;
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+pub struct Cli {
+	#[structopt(subcommand)]
+	pub subcommand: Option<Subcommand>,
+
+	#[structopt(flatten)]
+	pub run: RunCmd,
+}
+
+/// Possible subcommands of the main binary.
+#[derive(Debug, StructOpt)]
+pub enum Subcommand {
+	/// Key management cli utilities
+	Key(sc_cli::KeySubcommand),
+	/// Verify a signature for a message, provided on STDIN, with a given (public or secret) key.
+	Verify(sc_cli::VerifyCmd),
+
+	/// Generate a seed that provides a vanity address.
+	Vanity(sc_cli::VanityCmd),
+
+	/// Sign a message, with a given (secret) key.
+	Sign(sc_cli::SignCmd),
+
+	/// Build a chain specification.
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
+
+	/// The custom benchmark subcommmand benchmarking runtime pallets.
+	#[structopt(name = "benchmark", about = "Benchmark runtime pallets.")]
+	Benchmark(frame_benchmarking_cli::BenchmarkCmd),
+}

polkadot/bridges/bin/rialto/node/src/command.rs

@@ -0,0 +1,168 @@
+// Copyright 2019-2020 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::{Cli, Subcommand};
+use crate::service;
+use crate::service::new_partial;
+use rialto_runtime::Block;
+use sc_cli::{ChainSpec, Role, RuntimeVersion, SubstrateCli};
+use sc_service::PartialComponents;
+
+impl SubstrateCli for Cli {
+	fn impl_name() -> String {
+		"Rialto Bridge Node".into()
+	}
+
+	fn impl_version() -> String {
+		env!("CARGO_PKG_VERSION").into()
+	}
+
+	fn description() -> String {
+		"Rialto Bridge Node".into()
+	}
+
+	fn author() -> String {
+		"Parity Technologies".into()
+	}
+
+	fn support_url() -> String {
+		"https://github.com/paritytech/parity-bridges-common/".into()
+	}
+
+	fn copyright_start_year() -> i32 {
+		2019
+	}
+
+	fn executable_name() -> String {
+		"rialto-bridge-node".into()
+	}
+
+	fn native_runtime_version(_: &Box<dyn ChainSpec>) -> &'static RuntimeVersion {
+		&rialto_runtime::VERSION
+	}
+
+	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+		Ok(Box::new(
+			match id {
+				"" | "dev" => crate::chain_spec::Alternative::Development,
+				"local" => crate::chain_spec::Alternative::LocalTestnet,
+				_ => return Err(format!("Unsupported chain specification: {}", id)),
+			}
+			.load(),
+		))
+	}
+}
+
+/// Parse and run command line arguments
+pub fn run() -> sc_cli::Result<()> {
+	let cli = Cli::from_args();
+	sp_core::crypto::set_default_ss58_version(sp_core::crypto::Ss58AddressFormat::Custom(
+		rialto_runtime::SS58Prefix::get() as u16,
+	));
+
+	match &cli.subcommand {
+		Some(Subcommand::Benchmark(cmd)) => {
+			if cfg!(feature = "runtime-benchmarks") {
+				let runner = cli.create_runner(cmd)?;
+
+				runner.sync_run(|config| cmd.run::<Block, service::Executor>(config))
+			} else {
+				println!(
+					"Benchmarking wasn't enabled when building the node. \
+				You can enable it with `--features runtime-benchmarks`."
+				);
+				Ok(())
+			}
+		}
+		Some(Subcommand::Key(cmd)) => cmd.run(&cli),
+		Some(Subcommand::Sign(cmd)) => cmd.run(),
+		Some(Subcommand::Verify(cmd)) => cmd.run(),
+		Some(Subcommand::Vanity(cmd)) => cmd.run(),
+		Some(Subcommand::BuildSpec(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
+		}
+		Some(Subcommand::CheckBlock(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client,
+					task_manager,
+					import_queue,
+					..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		}
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client, task_manager, ..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		}
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client, task_manager, ..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		}
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client,
+					task_manager,
+					import_queue,
+					..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		}
+		Some(Subcommand::PurgeChain(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.database))
+		}
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents {
+					client,
+					task_manager,
+					backend,
+					..
+				} = new_partial(&config)?;
+				Ok((cmd.run(client, backend), task_manager))
+			})
+		}
+		None => {
+			let runner = cli.create_runner(&cli.run)?;
+			runner
+				.run_node_until_exit(|config| async move {
+					match config.role {
+						Role::Light => service::new_light(config),
+						_ => service::new_full(config),
+					}
+				})
+				.map_err(sc_cli::Error::Service)
+		}
+	}
+}

polkadot/bridges/bin/rialto/node/src/main.rs

@@ -0,0 +1,30 @@
+// Copyright 2019-2020 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 bridge node.
+
+#![warn(missing_docs)]
+
+mod chain_spec;
+#[macro_use]
+mod service;
+mod cli;
+mod command;
+
+/// Run the Rialto Node
+fn main() -> sc_cli::Result<()> {
+	command::run()
+}

polkadot/bridges/bin/rialto/node/src/service.rs

@@ -0,0 +1,433 @@
+// Copyright 2019-2020 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/>.
+
+//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+// UPDATE GUIDE:
+// 1) replace everything with node-template/src/service.rs contents (found in main Substrate repo);
+// 2) the only thing to keep from old code, is `rpc_extensions_builder` - we use our own custom RPCs;
+// 3) fix compilation errors;
+// 4) test :)
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+
+use rialto_runtime::{self, opaque::Block, RuntimeApi};
+use sc_client_api::{ExecutorProvider, RemoteBackend};
+use sc_executor::native_executor_instance;
+pub use sc_executor::NativeExecutor;
+use sc_finality_grandpa::SharedVoterState;
+use sc_keystore::LocalKeystore;
+use sc_service::{error::Error as ServiceError, Configuration, TaskManager};
+use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
+use sp_inherents::InherentDataProviders;
+use std::sync::Arc;
+use std::time::Duration;
+
+// Our native executor instance.
+native_executor_instance!(
+	pub Executor,
+	rialto_runtime::api::dispatch,
+	rialto_runtime::native_version,
+	frame_benchmarking::benchmarking::HostFunctions,
+);
+
+type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
+type FullBackend = sc_service::TFullBackend<Block>;
+type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
+
+#[allow(clippy::type_complexity)]
+pub fn new_partial(
+	config: &Configuration,
+) -> Result<
+	sc_service::PartialComponents<
+		FullClient,
+		FullBackend,
+		FullSelectChain,
+		sp_consensus::DefaultImportQueue<Block, FullClient>,
+		sc_transaction_pool::FullPool<Block, FullClient>,
+		(
+			sc_consensus_aura::AuraBlockImport<
+				Block,
+				FullClient,
+				sc_finality_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>,
+				AuraPair,
+			>,
+			sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+		),
+	>,
+	ServiceError,
+> {
+	if config.keystore_remote.is_some() {
+		return Err(ServiceError::Other("Remote Keystores are not supported.".to_string()));
+	}
+	let inherent_data_providers = sp_inherents::InherentDataProviders::new();
+
+	let (client, backend, keystore_container, task_manager) =
+		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
+	let client = Arc::new(client);
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
+		config.transaction_pool.clone(),
+		config.role.is_authority().into(),
+		config.prometheus_registry(),
+		task_manager.spawn_handle(),
+		client.clone(),
+	);
+
+	let (grandpa_block_import, grandpa_link) =
+		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain.clone())?;
+
+	let aura_block_import =
+		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
+
+	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
+		sc_consensus_aura::slot_duration(&*client)?,
+		aura_block_import.clone(),
+		Some(Box::new(grandpa_block_import)),
+		client.clone(),
+		inherent_data_providers.clone(),
+		&task_manager.spawn_essential_handle(),
+		config.prometheus_registry(),
+		sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone()),
+	)?;
+
+	Ok(sc_service::PartialComponents {
+		client,
+		backend,
+		task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		inherent_data_providers,
+		other: (aura_block_import, grandpa_link),
+	})
+}
+
+fn remote_keystore(_url: &str) -> Result<Arc<LocalKeystore>, &'static str> {
+	// FIXME: here would the concrete keystore be built,
+	//        must return a concrete type (NOT `LocalKeystore`) that
+	//        implements `CryptoStore` and `SyncCryptoStore`
+	Err("Remote Keystore not supported.")
+}
+
+/// Builds a new service for a full client.
+pub fn new_full(mut config: Configuration) -> Result<TaskManager, ServiceError> {
+	let sc_service::PartialComponents {
+		client,
+		backend,
+		mut task_manager,
+		import_queue,
+		mut keystore_container,
+		select_chain,
+		transaction_pool,
+		inherent_data_providers,
+		other: (block_import, grandpa_link),
+	} = new_partial(&config)?;
+
+	if let Some(url) = &config.keystore_remote {
+		match remote_keystore(url) {
+			Ok(k) => keystore_container.set_remote_keystore(k),
+			Err(e) => {
+				return Err(ServiceError::Other(format!(
+					"Error hooking up remote keystore for {}: {}",
+					url, e
+				)))
+			}
+		};
+	}
+
+	config
+		.network
+		.extra_sets
+		.push(sc_finality_grandpa::grandpa_peers_set_config());
+
+	let (network, network_status_sinks, system_rpc_tx, network_starter) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			on_demand: None,
+			block_announce_validator_builder: None,
+		})?;
+
+	if config.offchain_worker.enabled {
+		sc_service::build_offchain_workers(
+			&config,
+			backend.clone(),
+			task_manager.spawn_handle(),
+			client.clone(),
+			network.clone(),
+		);
+	}
+
+	let role = config.role.clone();
+	let force_authoring = config.force_authoring;
+	let backoff_authoring_blocks: Option<()> = None;
+	let name = config.network.node_name.clone();
+	let enable_grandpa = !config.disable_grandpa;
+	let prometheus_registry = config.prometheus_registry().cloned();
+
+	let rpc_extensions_builder = {
+		use bp_message_lane::{LaneId, MessageNonce};
+		use bp_runtime::{InstanceId, MILLAU_BRIDGE_INSTANCE};
+		use sc_finality_grandpa::FinalityProofProvider as GrandpaFinalityProofProvider;
+		use sp_core::storage::StorageKey;
+
+		// This struct is here to ease update process.
+
+		/// Rialto runtime from message-lane RPC point of view.
+		struct RialtoMessageLaneKeys;
+
+		impl pallet_message_lane_rpc::Runtime for RialtoMessageLaneKeys {
+			fn message_key(&self, instance: &InstanceId, lane: &LaneId, nonce: MessageNonce) -> Option<StorageKey> {
+				match *instance {
+					MILLAU_BRIDGE_INSTANCE => Some(rialto_runtime::millau_messages::message_key(lane, nonce)),
+					_ => None,
+				}
+			}
+
+			fn outbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					MILLAU_BRIDGE_INSTANCE => Some(rialto_runtime::millau_messages::outbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+
+			fn inbound_lane_data_key(&self, instance: &InstanceId, lane: &LaneId) -> Option<StorageKey> {
+				match *instance {
+					MILLAU_BRIDGE_INSTANCE => Some(rialto_runtime::millau_messages::inbound_lane_data_key(lane)),
+					_ => None,
+				}
+			}
+		}
+
+		use pallet_message_lane_rpc::{MessageLaneApi, MessageLaneRpcHandler};
+		use sc_finality_grandpa_rpc::{GrandpaApi, GrandpaRpcHandler};
+		use sc_rpc::DenyUnsafe;
+		use substrate_frame_rpc_system::{FullSystem, SystemApi};
+
+		let backend = backend.clone();
+		let client = client.clone();
+		let pool = transaction_pool.clone();
+
+		let justification_stream = grandpa_link.justification_stream();
+		let shared_authority_set = grandpa_link.shared_authority_set().clone();
+		let shared_voter_state = sc_finality_grandpa::SharedVoterState::empty();
+
+		let finality_proof_provider =
+			GrandpaFinalityProofProvider::new_for_service(backend.clone(), Some(shared_authority_set.clone()));
+
+		Box::new(move |_, subscription_executor| {
+			let mut io = jsonrpc_core::IoHandler::default();
+			io.extend_with(SystemApi::to_delegate(FullSystem::new(
+				client.clone(),
+				pool.clone(),
+				DenyUnsafe::No,
+			)));
+			io.extend_with(GrandpaApi::to_delegate(GrandpaRpcHandler::new(
+				shared_authority_set.clone(),
+				shared_voter_state.clone(),
+				justification_stream.clone(),
+				subscription_executor,
+				finality_proof_provider.clone(),
+			)));
+			io.extend_with(MessageLaneApi::to_delegate(MessageLaneRpcHandler::new(
+				backend.clone(),
+				Arc::new(RialtoMessageLaneKeys),
+			)));
+
+			io
+		})
+	};
+
+	let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		network: network.clone(),
+		client: client.clone(),
+		keystore: keystore_container.sync_keystore(),
+		task_manager: &mut task_manager,
+		transaction_pool: transaction_pool.clone(),
+		rpc_extensions_builder,
+		on_demand: None,
+		remote_blockchain: None,
+		backend,
+		network_status_sinks,
+		system_rpc_tx,
+		config,
+		telemetry_span: None,
+	})?;
+
+	if role.is_authority() {
+		let proposer = sc_basic_authorship::ProposerFactory::new(
+			task_manager.spawn_handle(),
+			client.clone(),
+			transaction_pool,
+			prometheus_registry.as_ref(),
+		);
+
+		let can_author_with = sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
+
+		let aura = sc_consensus_aura::start_aura::<_, _, _, _, _, AuraPair, _, _, _, _>(
+			sc_consensus_aura::slot_duration(&*client)?,
+			client.clone(),
+			select_chain,
+			block_import,
+			proposer,
+			network.clone(),
+			inherent_data_providers,
+			force_authoring,
+			backoff_authoring_blocks,
+			keystore_container.sync_keystore(),
+			can_author_with,
+		)?;
+
+		// the AURA authoring task is considered essential, i.e. if it
+		// fails we take down the service with it.
+		task_manager.spawn_essential_handle().spawn_blocking("aura", aura);
+	}
+
+	// if the node isn't actively participating in consensus then it doesn't
+	// need a keystore, regardless of which protocol we use below.
+	let keystore = if role.is_authority() {
+		Some(keystore_container.sync_keystore())
+	} else {
+		None
+	};
+
+	let grandpa_config = sc_finality_grandpa::Config {
+		// FIXME #1578 make this available through chainspec
+		gossip_duration: Duration::from_millis(333),
+		justification_period: 512,
+		name: Some(name),
+		observer_enabled: false,
+		keystore,
+		is_authority: role.is_authority(),
+	};
+
+	if enable_grandpa {
+		// start the full GRANDPA voter
+		// NOTE: non-authorities could run the GRANDPA observer protocol, but at
+		// this point the full voter should provide better guarantees of block
+		// and vote data availability than the observer. The observer has not
+		// been tested extensively yet and having most nodes in a network run it
+		// could lead to finality stalls.
+		let grandpa_config = sc_finality_grandpa::GrandpaParams {
+			config: grandpa_config,
+			link: grandpa_link,
+			network,
+			telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),
+			voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(),
+			prometheus_registry,
+			shared_voter_state: SharedVoterState::empty(),
+		};
+
+		// the GRANDPA voter task is considered infallible, i.e.
+		// if it fails we take down the service with it.
+		task_manager
+			.spawn_essential_handle()
+			.spawn_blocking("grandpa-voter", sc_finality_grandpa::run_grandpa_voter(grandpa_config)?);
+	}
+
+	network_starter.start_network();
+	Ok(task_manager)
+}
+
+/// Builds a new service for a light client.
+pub fn new_light(mut config: Configuration) -> Result<TaskManager, ServiceError> {
+	let (client, backend, keystore_container, mut task_manager, on_demand) =
+		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+
+	config
+		.network
+		.extra_sets
+		.push(sc_finality_grandpa::grandpa_peers_set_config());
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = Arc::new(sc_transaction_pool::BasicPool::new_light(
+		config.transaction_pool.clone(),
+		config.prometheus_registry(),
+		task_manager.spawn_handle(),
+		client.clone(),
+		on_demand.clone(),
+	));
+
+	let (grandpa_block_import, _) =
+		sc_finality_grandpa::block_import(client.clone(), &(client.clone() as Arc<_>), select_chain)?;
+
+	let aura_block_import =
+		sc_consensus_aura::AuraBlockImport::<_, _, _, AuraPair>::new(grandpa_block_import.clone(), client.clone());
+
+	let import_queue = sc_consensus_aura::import_queue::<_, _, _, AuraPair, _, _>(
+		sc_consensus_aura::slot_duration(&*client)?,
+		aura_block_import,
+		Some(Box::new(grandpa_block_import)),
+		client.clone(),
+		InherentDataProviders::new(),
+		&task_manager.spawn_essential_handle(),
+		config.prometheus_registry(),
+		sp_consensus::NeverCanAuthor,
+	)?;
+
+	let (network, network_status_sinks, system_rpc_tx, network_starter) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			on_demand: Some(on_demand.clone()),
+			block_announce_validator_builder: None,
+		})?;
+
+	if config.offchain_worker.enabled {
+		sc_service::build_offchain_workers(
+			&config,
+			backend.clone(),
+			task_manager.spawn_handle(),
+			client.clone(),
+			network.clone(),
+		);
+	}
+
+	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		remote_blockchain: Some(backend.remote_blockchain()),
+		transaction_pool,
+		task_manager: &mut task_manager,
+		on_demand: Some(on_demand),
+		rpc_extensions_builder: Box::new(|_, _| ()),
+		config,
+		client,
+		keystore: keystore_container.sync_keystore(),
+		backend,
+		network,
+		network_status_sinks,
+		system_rpc_tx,
+		telemetry_span: None,
+	})?;
+
+	network_starter.start_network();
+
+	Ok(task_manager)
+}

polkadot/bridges/bin/rialto/runtime/Cargo.toml

@@ -0,0 +1,129 @@
+[package]
+name = "rialto-runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+homepage = "https://substrate.dev"
+repository = "https://github.com/paritytech/parity-bridges-common/"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] }
+hex-literal = "0.3"
+libsecp256k1 = { version = "0.3.4", optional = true, default-features = false, features = ["hmac"] }
+serde = { version = "1.0.123", optional = true, features = ["derive"] }
+
+# Bridge dependencies
+
+bp-currency-exchange = { path = "../../../primitives/currency-exchange", default-features = false }
+bp-eth-poa = { path = "../../../primitives/ethereum-poa", default-features = false }
+bp-header-chain = { path = "../../../primitives/header-chain", default-features = false }
+bp-message-dispatch = { path = "../../../primitives/message-dispatch", default-features = false }
+bp-message-lane = { path = "../../../primitives/message-lane", default-features = false }
+bp-millau = { path = "../../../primitives/millau", default-features = false }
+bp-rialto = { path = "../../../primitives/rialto", default-features = false }
+bp-runtime = { path = "../../../primitives/runtime", default-features = false }
+bridge-runtime-common = { path = "../../runtime-common", default-features = false }
+pallet-bridge-eth-poa = { path = "../../../modules/ethereum", default-features = false }
+pallet-bridge-call-dispatch = { path = "../../../modules/call-dispatch", default-features = false }
+pallet-bridge-currency-exchange = { path = "../../../modules/currency-exchange", default-features = false }
+pallet-finality-verifier = { path = "../../../modules/finality-verifier", default-features = false }
+pallet-substrate-bridge = { path = "../../../modules/substrate", default-features = false }
+pallet-message-lane = { path = "../../../modules/message-lane", default-features = false }
+pallet-shift-session-manager = { path = "../../../modules/shift-session-manager", default-features = false }
+
+# Substrate Dependencies
+
+frame-benchmarking = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false, optional = true }
+frame-executive = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-support = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-system = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+frame-system-rpc-runtime-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-balances = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-randomness-collective-flip = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-session = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-sudo = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-timestamp = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+pallet-transaction-payment = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-api = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-block-builder = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-consensus-aura = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-core = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-finality-grandpa = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-inherents = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-io = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-offchain = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-session = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-std = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-transaction-pool = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-trie = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-version = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+
+[dev-dependencies]
+libsecp256k1 = { version = "0.3.4", features = ["hmac"] }
+
+[build-dependencies]
+wasm-builder-runner = { package = "substrate-wasm-builder-runner", version = "2.0.0" }
+
+[features]
+default = ["std"]
+std = [
+	"bp-currency-exchange/std",
+	"bp-eth-poa/std",
+	"bp-header-chain/std",
+	"bp-message-dispatch/std",
+	"bp-message-lane/std",
+	"bp-millau/std",
+	"bp-rialto/std",
+	"bp-runtime/std",
+	"bridge-runtime-common/std",
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-executive/std",
+	"frame-support/std",
+	"frame-system-rpc-runtime-api/std",
+	"frame-system/std",
+	"pallet-aura/std",
+	"pallet-balances/std",
+	"pallet-bridge-eth-poa/std",
+	"pallet-bridge-call-dispatch/std",
+	"pallet-bridge-currency-exchange/std",
+	"pallet-finality-verifier/std",
+	"pallet-grandpa/std",
+	"pallet-message-lane/std",
+	"pallet-randomness-collective-flip/std",
+	"pallet-shift-session-manager/std",
+	"pallet-substrate-bridge/std",
+	"pallet-sudo/std",
+	"pallet-timestamp/std",
+	"pallet-transaction-payment/std",
+	"serde",
+	"sp-api/std",
+	"sp-block-builder/std",
+	"sp-consensus-aura/std",
+	"sp-core/std",
+	"sp-finality-grandpa/std",
+	"sp-inherents/std",
+	"sp-io/std",
+	"sp-offchain/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-std/std",
+	"sp-transaction-pool/std",
+	"sp-trie/std",
+	"sp-version/std",
+]
+runtime-benchmarks = [
+	"bridge-runtime-common/runtime-benchmarks",
+	"frame-benchmarking",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"libsecp256k1",
+	"pallet-bridge-currency-exchange/runtime-benchmarks",
+	"pallet-bridge-eth-poa/runtime-benchmarks",
+	"pallet-message-lane/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]

polkadot/bridges/bin/rialto/runtime/build.rs

@@ -0,0 +1,26 @@
+// Copyright 2019-2020 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 wasm_builder_runner::WasmBuilder;
+
+fn main() {
+	WasmBuilder::new()
+		.with_current_project()
+		.with_wasm_builder_from_crates("1.0.11")
+		.export_heap_base()
+		.import_memory()
+		.build()
+}

polkadot/bridges/bin/rialto/runtime/src/benches.rs

@@ -0,0 +1,37 @@
+// Copyright 2020 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/>.
+
+//! We want to use a different validator configuration for benchmarking than what's used in Kovan
+//! or in our Rialto test network. However, we can't configure a new validator set on the fly which
+//! means we need to wire the runtime together like this
+
+use pallet_bridge_eth_poa::{ValidatorsConfiguration, ValidatorsSource};
+use sp_std::vec;
+
+pub use crate::kovan::{
+	genesis_header, genesis_validators, BridgeAuraConfiguration, FinalityVotesCachingInterval, PruningStrategy,
+};
+
+frame_support::parameter_types! {
+	pub BridgeValidatorsConfiguration: pallet_bridge_eth_poa::ValidatorsConfiguration = bench_validator_config();
+}
+
+fn bench_validator_config() -> ValidatorsConfiguration {
+	ValidatorsConfiguration::Multi(vec![
+		(0, ValidatorsSource::List(vec![[1; 20].into()])),
+		(1, ValidatorsSource::Contract([3; 20].into(), vec![[1; 20].into()])),
+	])
+}

polkadot/bridges/bin/rialto/runtime/src/exchange.rs

@@ -0,0 +1,260 @@
+// Copyright 2019-2020 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/>.
+
+//! Support for PoA -> Substrate native tokens exchange.
+//!
+//! If you want to exchange native PoA tokens for native Substrate
+//! chain tokens, you need to:
+//! 1) send some PoA tokens to `LOCK_FUNDS_ADDRESS` address on PoA chain. Data field of
+//!    the transaction must be SCALE-encoded id of Substrate account that will receive
+//!    funds on Substrate chain;
+//! 2) wait until the 'lock funds' transaction is mined on PoA chain;
+//! 3) wait until the block containing the 'lock funds' transaction is finalized on PoA chain;
+//! 4) wait until the required PoA header and its finality are provided
+//!    to the PoA -> Substrate bridge module (it can be provided by you);
+//! 5) receive tokens by providing proof-of-inclusion of PoA transaction.
+
+use bp_currency_exchange::{
+	Error as ExchangeError, LockFundsTransaction, MaybeLockFundsTransaction, Result as ExchangeResult,
+};
+use bp_eth_poa::{transaction_decode_rlp, RawTransaction, RawTransactionReceipt};
+use codec::{Decode, Encode};
+use frame_support::RuntimeDebug;
+use hex_literal::hex;
+use sp_std::vec::Vec;
+
+/// Ethereum address where locked PoA funds must be sent to.
+pub const LOCK_FUNDS_ADDRESS: [u8; 20] = hex!("DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF");
+
+/// Ethereum transaction inclusion proof.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug)]
+pub struct EthereumTransactionInclusionProof {
+	/// Hash of the block with transaction.
+	pub block: sp_core::H256,
+	/// Index of the transaction within the block.
+	pub index: u64,
+	/// The proof itself (right now it is all RLP-encoded transactions of the block +
+	/// RLP-encoded receipts of all transactions of the block).
+	pub proof: Vec<(RawTransaction, RawTransactionReceipt)>,
+}
+
+/// We uniquely identify transfer by the pair (sender, nonce).
+///
+/// The assumption is that this pair will never appear more than once in
+/// transactions included into finalized blocks. This is obviously true
+/// for any existing eth-like chain (that keep current tx format), because
+/// otherwise transaction can be replayed over and over.
+#[derive(Encode, Decode, PartialEq, RuntimeDebug)]
+pub struct EthereumTransactionTag {
+	/// Account that has locked funds.
+	pub account: [u8; 20],
+	/// Lock transaction nonce.
+	pub nonce: sp_core::U256,
+}
+
+/// Eth transaction from runtime perspective.
+pub struct EthTransaction;
+
+impl MaybeLockFundsTransaction for EthTransaction {
+	type Transaction = RawTransaction;
+	type Id = EthereumTransactionTag;
+	type Recipient = crate::AccountId;
+	type Amount = crate::Balance;
+
+	fn parse(
+		raw_tx: &Self::Transaction,
+	) -> ExchangeResult<LockFundsTransaction<Self::Id, Self::Recipient, Self::Amount>> {
+		let tx = transaction_decode_rlp(raw_tx).map_err(|_| ExchangeError::InvalidTransaction)?;
+
+		// we only accept transactions sending funds directly to the pre-configured address
+		if tx.unsigned.to != Some(LOCK_FUNDS_ADDRESS.into()) {
+			frame_support::debug::trace!(
+				target: "runtime",
+				"Failed to parse fund locks transaction. Invalid peer recipient: {:?}",
+				tx.unsigned.to,
+			);
+
+			return Err(ExchangeError::InvalidTransaction);
+		}
+
+		let mut recipient_raw = sp_core::H256::default();
+		match tx.unsigned.payload.len() {
+			32 => recipient_raw.as_fixed_bytes_mut().copy_from_slice(&tx.unsigned.payload),
+			len => {
+				frame_support::debug::trace!(
+					target: "runtime",
+					"Failed to parse fund locks transaction. Invalid recipient length: {}",
+					len,
+				);
+
+				return Err(ExchangeError::InvalidRecipient);
+			}
+		}
+		let amount = tx.unsigned.value.low_u128();
+
+		if tx.unsigned.value != amount.into() {
+			frame_support::debug::trace!(
+				target: "runtime",
+				"Failed to parse fund locks transaction. Invalid amount: {}",
+				tx.unsigned.value,
+			);
+
+			return Err(ExchangeError::InvalidAmount);
+		}
+
+		Ok(LockFundsTransaction {
+			id: EthereumTransactionTag {
+				account: *tx.sender.as_fixed_bytes(),
+				nonce: tx.unsigned.nonce,
+			},
+			recipient: crate::AccountId::from(*recipient_raw.as_fixed_bytes()),
+			amount,
+		})
+	}
+}
+
+/// Prepares everything required to bench claim of funds locked by given transaction.
+#[cfg(feature = "runtime-benchmarks")]
+pub(crate) fn prepare_environment_for_claim<T: pallet_bridge_eth_poa::Config<I>, I: frame_support::traits::Instance>(
+	transactions: &[(RawTransaction, RawTransactionReceipt)],
+) -> bp_eth_poa::H256 {
+	use bp_eth_poa::compute_merkle_root;
+	use pallet_bridge_eth_poa::{
+		test_utils::{insert_dummy_header, validator_utils::validator, HeaderBuilder},
+		BridgeStorage, Storage,
+	};
+
+	let mut storage = BridgeStorage::<T, I>::new();
+	let header = HeaderBuilder::with_parent_number_on_runtime::<T, I>(0)
+		.transactions_root(compute_merkle_root(transactions.iter().map(|(tx, _)| tx)))
+		.receipts_root(compute_merkle_root(transactions.iter().map(|(_, receipt)| receipt)))
+		.sign_by(&validator(0));
+	let header_id = header.compute_id();
+	insert_dummy_header(&mut storage, header);
+	storage.finalize_and_prune_headers(Some(header_id), 0);
+
+	header_id.hash
+}
+
+/// Prepare signed ethereum lock-funds transaction.
+#[cfg(any(feature = "runtime-benchmarks", test))]
+pub(crate) fn prepare_ethereum_transaction(
+	recipient: &crate::AccountId,
+	editor: impl Fn(&mut bp_eth_poa::UnsignedTransaction),
+) -> (RawTransaction, RawTransactionReceipt) {
+	use bp_eth_poa::{signatures::SignTransaction, Receipt, TransactionOutcome};
+
+	// prepare tx for OpenEthereum private dev chain:
+	// chain id is 0x11
+	// sender secret is 0x4d5db4107d237df6a3d58ee5f70ae63d73d7658d4026f2eefd2f204c81682cb7
+	let chain_id = 0x11;
+	let signer = secp256k1::SecretKey::parse(&hex!(
+		"4d5db4107d237df6a3d58ee5f70ae63d73d7658d4026f2eefd2f204c81682cb7"
+	))
+	.unwrap();
+	let recipient_raw: &[u8; 32] = recipient.as_ref();
+	let mut eth_tx = bp_eth_poa::UnsignedTransaction {
+		nonce: 0.into(),
+		to: Some(LOCK_FUNDS_ADDRESS.into()),
+		value: 100.into(),
+		gas: 100_000.into(),
+		gas_price: 100_000.into(),
+		payload: recipient_raw.to_vec(),
+	};
+	editor(&mut eth_tx);
+	(
+		eth_tx.sign_by(&signer, Some(chain_id)),
+		Receipt {
+			outcome: TransactionOutcome::StatusCode(1),
+			gas_used: Default::default(),
+			log_bloom: Default::default(),
+			logs: Vec::new(),
+		}
+		.rlp(),
+	)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use hex_literal::hex;
+
+	fn ferdie() -> crate::AccountId {
+		hex!("1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c").into()
+	}
+
+	#[test]
+	fn valid_transaction_accepted() {
+		assert_eq!(
+			EthTransaction::parse(&prepare_ethereum_transaction(&ferdie(), |_| {}).0),
+			Ok(LockFundsTransaction {
+				id: EthereumTransactionTag {
+					account: hex!("00a329c0648769a73afac7f9381e08fb43dbea72"),
+					nonce: 0.into(),
+				},
+				recipient: ferdie(),
+				amount: 100,
+			}),
+		);
+	}
+
+	#[test]
+	fn invalid_transaction_rejected() {
+		assert_eq!(
+			EthTransaction::parse(&Vec::new()),
+			Err(ExchangeError::InvalidTransaction),
+		);
+	}
+
+	#[test]
+	fn transaction_with_invalid_peer_recipient_rejected() {
+		assert_eq!(
+			EthTransaction::parse(
+				&prepare_ethereum_transaction(&ferdie(), |tx| {
+					tx.to = None;
+				})
+				.0
+			),
+			Err(ExchangeError::InvalidTransaction),
+		);
+	}
+
+	#[test]
+	fn transaction_with_invalid_recipient_rejected() {
+		assert_eq!(
+			EthTransaction::parse(
+				&prepare_ethereum_transaction(&ferdie(), |tx| {
+					tx.payload.clear();
+				})
+				.0
+			),
+			Err(ExchangeError::InvalidRecipient),
+		);
+	}
+
+	#[test]
+	fn transaction_with_invalid_amount_rejected() {
+		assert_eq!(
+			EthTransaction::parse(
+				&prepare_ethereum_transaction(&ferdie(), |tx| {
+					tx.value = sp_core::U256::from(u128::max_value()) + sp_core::U256::from(1);
+				})
+				.0
+			),
+			Err(ExchangeError::InvalidAmount),
+		);
+	}
+}

polkadot/bridges/bin/rialto/runtime/src/kovan.rs

@@ -0,0 +1,192 @@
+// Copyright 2019-2020 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::exchange::EthereumTransactionInclusionProof;
+
+use bp_eth_poa::{Address, AuraHeader, RawTransaction, U256};
+use bp_header_chain::InclusionProofVerifier;
+use frame_support::RuntimeDebug;
+use hex_literal::hex;
+use pallet_bridge_eth_poa::{
+	AuraConfiguration, ChainTime as TChainTime, PruningStrategy as BridgePruningStrategy, ValidatorsConfiguration,
+	ValidatorsSource,
+};
+use sp_std::prelude::*;
+
+frame_support::parameter_types! {
+	pub const FinalityVotesCachingInterval: Option<u64> = Some(16);
+	pub BridgeAuraConfiguration: AuraConfiguration =
+		kovan_aura_configuration();
+	pub BridgeValidatorsConfiguration: ValidatorsConfiguration =
+		kovan_validators_configuration();
+}
+
+/// Max number of finalized headers to keep. It is equivalent of ~24 hours of
+/// finalized blocks on current Kovan chain.
+const FINALIZED_HEADERS_TO_KEEP: u64 = 20_000;
+
+/// Aura engine configuration for Kovan chain.
+pub fn kovan_aura_configuration() -> AuraConfiguration {
+	AuraConfiguration {
+		empty_steps_transition: u64::max_value(),
+		strict_empty_steps_transition: 0,
+		validate_step_transition: 0x16e360,
+		validate_score_transition: 0x41a3c4,
+		two_thirds_majority_transition: u64::max_value(),
+		min_gas_limit: 0x1388.into(),
+		max_gas_limit: U256::max_value(),
+		maximum_extra_data_size: 0x20,
+	}
+}
+
+/// Validators configuration for Kovan chain.
+pub fn kovan_validators_configuration() -> ValidatorsConfiguration {
+	ValidatorsConfiguration::Multi(vec![
+		(0, ValidatorsSource::List(genesis_validators())),
+		(
+			10960440,
+			ValidatorsSource::List(vec![
+				hex!("00D6Cc1BA9cf89BD2e58009741f4F7325BAdc0ED").into(),
+				hex!("0010f94b296a852aaac52ea6c5ac72e03afd032d").into(),
+				hex!("00a0a24b9f0e5ec7aa4c7389b8302fd0123194de").into(),
+			]),
+		),
+		(
+			10960500,
+			ValidatorsSource::Contract(
+				hex!("aE71807C1B0a093cB1547b682DC78316D945c9B8").into(),
+				vec![
+					hex!("d05f7478c6aa10781258c5cc8b4f385fc8fa989c").into(),
+					hex!("03801efb0efe2a25ede5dd3a003ae880c0292e4d").into(),
+					hex!("a4df255ecf08bbf2c28055c65225c9a9847abd94").into(),
+					hex!("596e8221a30bfe6e7eff67fee664a01c73ba3c56").into(),
+					hex!("faadface3fbd81ce37b0e19c0b65ff4234148132").into(),
+				],
+			),
+		),
+	])
+}
+
+/// Genesis validators set of Kovan chain.
+pub fn genesis_validators() -> Vec<Address> {
+	vec![
+		hex!("00D6Cc1BA9cf89BD2e58009741f4F7325BAdc0ED").into(),
+		hex!("00427feae2419c15b89d1c21af10d1b6650a4d3d").into(),
+		hex!("4Ed9B08e6354C70fE6F8CB0411b0d3246b424d6c").into(),
+		hex!("0020ee4Be0e2027d76603cB751eE069519bA81A1").into(),
+		hex!("0010f94b296a852aaac52ea6c5ac72e03afd032d").into(),
+		hex!("007733a1FE69CF3f2CF989F81C7b4cAc1693387A").into(),
+		hex!("00E6d2b931F55a3f1701c7389d592a7778897879").into(),
+		hex!("00e4a10650e5a6D6001C38ff8E64F97016a1645c").into(),
+		hex!("00a0a24b9f0e5ec7aa4c7389b8302fd0123194de").into(),
+	]
+}
+
+/// Genesis header of the Kovan chain.
+pub fn genesis_header() -> AuraHeader {
+	AuraHeader {
+		parent_hash: Default::default(),
+		timestamp: 0,
+		number: 0,
+		author: Default::default(),
+		transactions_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
+		uncles_hash: hex!("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347").into(),
+		extra_data: vec![],
+		state_root: hex!("2480155b48a1cea17d67dbfdfaafe821c1d19cdd478c5358e8ec56dec24502b2").into(),
+		receipts_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
+		log_bloom: Default::default(),
+		gas_used: Default::default(),
+		gas_limit: 6000000.into(),
+		difficulty: 131072.into(),
+		seal: vec![
+			vec![128],
+			vec![
+				184, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			],
+		],
+	}
+}
+
+/// Kovan headers pruning strategy.
+///
+/// We do not prune unfinalized headers because exchange module only accepts
+/// claims from finalized headers. And if we're pruning unfinalized headers, then
+/// some claims may never be accepted.
+#[derive(Default, RuntimeDebug)]
+pub struct PruningStrategy;
+
+impl BridgePruningStrategy for PruningStrategy {
+	fn pruning_upper_bound(&mut self, _best_number: u64, best_finalized_number: u64) -> u64 {
+		best_finalized_number.saturating_sub(FINALIZED_HEADERS_TO_KEEP)
+	}
+}
+
+/// PoA Header timestamp verification against `Timestamp` pallet.
+#[derive(Default, RuntimeDebug)]
+pub struct ChainTime;
+
+impl TChainTime for ChainTime {
+	fn is_timestamp_ahead(&self, timestamp: u64) -> bool {
+		let now = super::Timestamp::now();
+		timestamp > now
+	}
+}
+
+/// The Kovan Blockchain as seen by the runtime.
+pub struct KovanBlockchain;
+
+impl InclusionProofVerifier for KovanBlockchain {
+	type Transaction = RawTransaction;
+	type TransactionInclusionProof = EthereumTransactionInclusionProof;
+
+	fn verify_transaction_inclusion_proof(proof: &Self::TransactionInclusionProof) -> Option<Self::Transaction> {
+		let is_transaction_finalized =
+			crate::BridgeKovan::verify_transaction_finalized(proof.block, proof.index, &proof.proof);
+
+		if !is_transaction_finalized {
+			return None;
+		}
+
+		proof.proof.get(proof.index as usize).map(|(tx, _)| tx.clone())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn pruning_strategy_keeps_enough_headers() {
+		assert_eq!(
+			PruningStrategy::default().pruning_upper_bound(100_000, 10_000),
+			0,
+			"10_000 <= 20_000 => nothing should be pruned yet",
+		);
+
+		assert_eq!(
+			PruningStrategy::default().pruning_upper_bound(100_000, 20_000),
+			0,
+			"20_000 <= 20_000 => nothing should be pruned yet",
+		);
+
+		assert_eq!(
+			PruningStrategy::default().pruning_upper_bound(100_000, 30_000),
+			10_000,
+			"20_000 <= 30_000 => we're ready to prune first 10_000 headers",
+		);
+	}
+}

polkadot/bridges/bin/rialto/runtime/src/millau_messages.rs

@@ -0,0 +1,254 @@
+// Copyright 2019-2020 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/>.
+
+//! Everything required to serve Millau <-> Rialto message lanes.
+
+use crate::Runtime;
+
+use bp_message_lane::{
+	source_chain::TargetHeaderChain,
+	target_chain::{ProvedMessages, SourceHeaderChain},
+	InboundLaneData, LaneId, Message, MessageNonce, Parameter as MessageLaneParameter,
+};
+use bp_runtime::{InstanceId, MILLAU_BRIDGE_INSTANCE};
+use bridge_runtime_common::messages::{self, ChainWithMessageLanes, MessageBridge};
+use codec::{Decode, Encode};
+use frame_support::{
+	parameter_types,
+	weights::{DispatchClass, Weight, WeightToFeePolynomial},
+	RuntimeDebug,
+};
+use sp_core::storage::StorageKey;
+use sp_runtime::{FixedPointNumber, FixedU128};
+use sp_std::{convert::TryFrom, ops::RangeInclusive};
+
+parameter_types! {
+	/// Millau to Rialto conversion rate. Initially we treat both tokens as equal.
+	storage MillauToRialtoConversionRate: FixedU128 = 1.into();
+}
+
+/// Storage key of the Rialto -> Millau message in the runtime storage.
+pub fn message_key(lane: &LaneId, nonce: MessageNonce) -> StorageKey {
+	pallet_message_lane::storage_keys::message_key::<Runtime, <Rialto as ChainWithMessageLanes>::MessageLaneInstance>(
+		lane, nonce,
+	)
+}
+
+/// Storage key of the Rialto -> Millau message lane state in the runtime storage.
+pub fn outbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	pallet_message_lane::storage_keys::outbound_lane_data_key::<<Rialto as ChainWithMessageLanes>::MessageLaneInstance>(
+		lane,
+	)
+}
+
+/// Storage key of the Millau -> Rialto message lane state in the runtime storage.
+pub fn inbound_lane_data_key(lane: &LaneId) -> StorageKey {
+	pallet_message_lane::storage_keys::inbound_lane_data_key::<
+		Runtime,
+		<Rialto as ChainWithMessageLanes>::MessageLaneInstance,
+	>(lane)
+}
+
+/// Message payload for Rialto -> Millau messages.
+pub type ToMillauMessagePayload = messages::source::FromThisChainMessagePayload<WithMillauMessageBridge>;
+
+/// Message verifier for Rialto -> Millau messages.
+pub type ToMillauMessageVerifier = messages::source::FromThisChainMessageVerifier<WithMillauMessageBridge>;
+
+/// Message payload for Millau -> Rialto messages.
+pub type FromMillauMessagePayload = messages::target::FromBridgedChainMessagePayload<WithMillauMessageBridge>;
+
+/// Encoded Rialto Call as it comes from Millau.
+pub type FromMillauEncodedCall = messages::target::FromBridgedChainEncodedMessageCall<WithMillauMessageBridge>;
+
+/// Call-dispatch based message dispatch for Millau -> Rialto messages.
+pub type FromMillauMessageDispatch = messages::target::FromBridgedChainMessageDispatch<
+	WithMillauMessageBridge,
+	crate::Runtime,
+	pallet_bridge_call_dispatch::DefaultInstance,
+>;
+
+/// Messages proof for Millau -> Rialto messages.
+pub type FromMillauMessagesProof = messages::target::FromBridgedChainMessagesProof<bp_millau::Hash>;
+
+/// Messages delivery proof for Rialto -> Millau messages.
+pub type ToMillauMessagesDeliveryProof = messages::source::FromBridgedChainMessagesDeliveryProof<bp_millau::Hash>;
+
+/// Millau <-> Rialto message bridge.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct WithMillauMessageBridge;
+
+impl MessageBridge for WithMillauMessageBridge {
+	const INSTANCE: InstanceId = MILLAU_BRIDGE_INSTANCE;
+
+	const RELAYER_FEE_PERCENT: u32 = 10;
+
+	type ThisChain = Rialto;
+	type BridgedChain = Millau;
+
+	fn maximal_extrinsic_size_on_target_chain() -> u32 {
+		bp_millau::max_extrinsic_size()
+	}
+
+	fn weight_limits_of_message_on_bridged_chain(_message_payload: &[u8]) -> RangeInclusive<Weight> {
+		// we don't want to relay too large messages + keep reserve for future upgrades
+		let upper_limit = messages::target::maximal_incoming_message_dispatch_weight(bp_millau::max_extrinsic_weight());
+
+		// we're charging for payload bytes in `WithMillauMessageBridge::weight_of_delivery_transaction` function
+		//
+		// this bridge may be used to deliver all kind of messages, so we're not making any assumptions about
+		// minimal dispatch weight here
+
+		0..=upper_limit
+	}
+
+	fn weight_of_delivery_transaction(message_payload: &[u8]) -> Weight {
+		let message_payload_len = u32::try_from(message_payload.len())
+			.map(Into::into)
+			.unwrap_or(Weight::MAX);
+		let extra_bytes_in_payload =
+			message_payload_len.saturating_sub(pallet_message_lane::EXPECTED_DEFAULT_MESSAGE_LENGTH.into());
+		messages::transaction_weight_without_multiplier(
+			bp_millau::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
+			message_payload_len.saturating_add(bp_rialto::EXTRA_STORAGE_PROOF_SIZE as _),
+			extra_bytes_in_payload
+				.saturating_mul(bp_millau::ADDITIONAL_MESSAGE_BYTE_DELIVERY_WEIGHT)
+				.saturating_add(bp_millau::DEFAULT_MESSAGE_DELIVERY_TX_WEIGHT),
+		)
+	}
+
+	fn weight_of_delivery_confirmation_transaction_on_this_chain() -> Weight {
+		let inbounded_data_size: Weight =
+			InboundLaneData::<bp_millau::AccountId>::encoded_size_hint(bp_millau::MAXIMAL_ENCODED_ACCOUNT_ID_SIZE, 1)
+				.map(Into::into)
+				.unwrap_or(Weight::MAX);
+
+		messages::transaction_weight_without_multiplier(
+			bp_millau::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic,
+			inbounded_data_size.saturating_add(bp_millau::EXTRA_STORAGE_PROOF_SIZE as _),
+			bp_rialto::MAX_SINGLE_MESSAGE_DELIVERY_CONFIRMATION_TX_WEIGHT,
+		)
+	}
+
+	fn this_weight_to_this_balance(weight: Weight) -> bp_rialto::Balance {
+		<crate::Runtime as pallet_transaction_payment::Config>::WeightToFee::calc(&weight)
+	}
+
+	fn bridged_weight_to_bridged_balance(weight: Weight) -> bp_millau::Balance {
+		// we're using the same weights in both chains now
+		<crate::Runtime as pallet_transaction_payment::Config>::WeightToFee::calc(&weight) as _
+	}
+
+	fn bridged_balance_to_this_balance(bridged_balance: bp_millau::Balance) -> bp_rialto::Balance {
+		bp_rialto::Balance::try_from(MillauToRialtoConversionRate::get().saturating_mul_int(bridged_balance))
+			.unwrap_or(bp_rialto::Balance::MAX)
+	}
+}
+
+/// Rialto chain from message lane point of view.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct Rialto;
+
+impl messages::ChainWithMessageLanes for Rialto {
+	type Hash = bp_rialto::Hash;
+	type AccountId = bp_rialto::AccountId;
+	type Signer = bp_rialto::AccountSigner;
+	type Signature = bp_rialto::Signature;
+	type Call = crate::Call;
+	type Weight = Weight;
+	type Balance = bp_rialto::Balance;
+
+	type MessageLaneInstance = crate::WithMillauMessageLaneInstance;
+}
+
+impl messages::ThisChainWithMessageLanes for Rialto {
+	fn is_outbound_lane_enabled(lane: &LaneId) -> bool {
+		*lane == LaneId::default()
+	}
+
+	fn maximal_pending_messages_at_outbound_lane() -> MessageNonce {
+		MessageNonce::MAX
+	}
+}
+
+/// Millau chain from message lane point of view.
+#[derive(RuntimeDebug, Clone, Copy)]
+pub struct Millau;
+
+impl messages::ChainWithMessageLanes for Millau {
+	type Hash = bp_millau::Hash;
+	type AccountId = bp_millau::AccountId;
+	type Signer = bp_millau::AccountSigner;
+	type Signature = bp_millau::Signature;
+	type Call = (); // unknown to us
+	type Weight = Weight;
+	type Balance = bp_millau::Balance;
+
+	type MessageLaneInstance = pallet_message_lane::DefaultInstance;
+}
+
+impl TargetHeaderChain<ToMillauMessagePayload, bp_millau::AccountId> for Millau {
+	type Error = &'static str;
+	// The proof is:
+	// - hash of the header this proof has been created with;
+	// - the storage proof of one or several keys;
+	// - id of the lane we prove state of.
+	type MessagesDeliveryProof = ToMillauMessagesDeliveryProof;
+
+	fn verify_message(payload: &ToMillauMessagePayload) -> Result<(), Self::Error> {
+		messages::source::verify_chain_message::<WithMillauMessageBridge>(payload)
+	}
+
+	fn verify_messages_delivery_proof(
+		proof: Self::MessagesDeliveryProof,
+	) -> Result<(LaneId, InboundLaneData<bp_rialto::AccountId>), Self::Error> {
+		messages::source::verify_messages_delivery_proof::<WithMillauMessageBridge, Runtime>(proof)
+	}
+}
+
+impl SourceHeaderChain<bp_millau::Balance> for Millau {
+	type Error = &'static str;
+	// The proof is:
+	// - hash of the header this proof has been created with;
+	// - the storage proof of one or several keys;
+	// - id of the lane we prove messages for;
+	// - inclusive range of messages nonces that are proved.
+	type MessagesProof = FromMillauMessagesProof;
+
+	fn verify_messages_proof(
+		proof: Self::MessagesProof,
+		messages_count: u32,
+	) -> Result<ProvedMessages<Message<bp_millau::Balance>>, Self::Error> {
+		messages::target::verify_messages_proof::<WithMillauMessageBridge, Runtime>(proof, messages_count)
+	}
+}
+
+/// Rialto -> Millau message lane pallet parameters.
+#[derive(RuntimeDebug, Clone, Encode, Decode, PartialEq, Eq)]
+pub enum RialtoToMillauMessageLaneParameter {
+	/// The conversion formula we use is: `RialtoTokens = MillauTokens * conversion_rate`.
+	MillauToRialtoConversionRate(FixedU128),
+}
+
+impl MessageLaneParameter for RialtoToMillauMessageLaneParameter {
+	fn save(&self) {
+		match *self {
+			RialtoToMillauMessageLaneParameter::MillauToRialtoConversionRate(ref conversion_rate) => {
+				MillauToRialtoConversionRate::set(conversion_rate)
+			}
+		}
+	}
+}

polkadot/bridges/bin/rialto/runtime/src/rialto_poa.rs

@@ -0,0 +1,175 @@
+// Copyright 2020 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/>.
+
+//! Configuration parameters for the Rialto PoA chain.
+
+use crate::exchange::EthereumTransactionInclusionProof;
+
+use bp_eth_poa::{Address, AuraHeader, RawTransaction, U256};
+use bp_header_chain::InclusionProofVerifier;
+use frame_support::RuntimeDebug;
+use hex_literal::hex;
+use pallet_bridge_eth_poa::{
+	AuraConfiguration, ChainTime as TChainTime, PruningStrategy as TPruningStrategy, ValidatorsConfiguration,
+	ValidatorsSource,
+};
+use sp_std::prelude::*;
+
+frame_support::parameter_types! {
+	pub const FinalityVotesCachingInterval: Option<u64> = Some(8);
+	pub BridgeAuraConfiguration: AuraConfiguration =
+		aura_configuration();
+	pub BridgeValidatorsConfiguration: ValidatorsConfiguration =
+		validators_configuration();
+}
+
+/// Max number of finalized headers to keep.
+const FINALIZED_HEADERS_TO_KEEP: u64 = 5_000;
+
+/// Aura engine configuration for Rialto chain.
+pub fn aura_configuration() -> AuraConfiguration {
+	AuraConfiguration {
+		empty_steps_transition: 0xfffffffff,
+		strict_empty_steps_transition: 0,
+		validate_step_transition: 0,
+		validate_score_transition: 0,
+		two_thirds_majority_transition: u64::max_value(),
+		min_gas_limit: 0x1388.into(),
+		max_gas_limit: U256::max_value(),
+		maximum_extra_data_size: 0x20,
+	}
+}
+
+/// Validators configuration for Rialto PoA chain.
+pub fn validators_configuration() -> ValidatorsConfiguration {
+	ValidatorsConfiguration::Single(ValidatorsSource::List(genesis_validators()))
+}
+
+/// Genesis validators set of Rialto PoA chain.
+pub fn genesis_validators() -> Vec<Address> {
+	vec![
+		hex!("005e714f896a8b7cede9d38688c1a81de72a58e4").into(),
+		hex!("007594304039c2937a12220338aab821d819f5a4").into(),
+		hex!("004e7a39907f090e19b0b80a277e77b72b22e269").into(),
+	]
+}
+
+/// Genesis header of the Rialto PoA chain.
+///
+/// To obtain genesis header from a running node, invoke:
+/// ```bash
+/// $ http localhost:8545 jsonrpc=2.0 id=1 method=eth_getBlockByNumber params:='["earliest", false]' -v
+/// ```
+pub fn genesis_header() -> AuraHeader {
+	AuraHeader {
+		parent_hash: Default::default(),
+		timestamp: 0,
+		number: 0,
+		author: Default::default(),
+		transactions_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
+		uncles_hash: hex!("1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347").into(),
+		extra_data: vec![],
+		state_root: hex!("a992d04c791620ed7ed96555a80cf0568355bb4bee2656f46899a4372f25f248").into(),
+		receipts_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
+		log_bloom: Default::default(),
+		gas_used: Default::default(),
+		gas_limit: 0x222222.into(),
+		difficulty: 0x20000.into(),
+		seal: vec![vec![0x80], {
+			let mut vec = vec![0xb8, 0x41];
+			vec.resize(67, 0);
+			vec
+		}],
+	}
+}
+
+/// Rialto PoA headers pruning strategy.
+///
+/// We do not prune unfinalized headers because exchange module only accepts
+/// claims from finalized headers. And if we're pruning unfinalized headers, then
+/// some claims may never be accepted.
+#[derive(Default, RuntimeDebug)]
+pub struct PruningStrategy;
+
+impl TPruningStrategy for PruningStrategy {
+	fn pruning_upper_bound(&mut self, _best_number: u64, best_finalized_number: u64) -> u64 {
+		best_finalized_number.saturating_sub(FINALIZED_HEADERS_TO_KEEP)
+	}
+}
+
+/// ChainTime provider
+#[derive(Default)]
+pub struct ChainTime;
+
+impl TChainTime for ChainTime {
+	fn is_timestamp_ahead(&self, timestamp: u64) -> bool {
+		let now = super::Timestamp::now();
+		timestamp > now
+	}
+}
+
+/// The Rialto PoA Blockchain as seen by the runtime.
+pub struct RialtoBlockchain;
+
+impl InclusionProofVerifier for RialtoBlockchain {
+	type Transaction = RawTransaction;
+	type TransactionInclusionProof = EthereumTransactionInclusionProof;
+
+	fn verify_transaction_inclusion_proof(proof: &Self::TransactionInclusionProof) -> Option<Self::Transaction> {
+		let is_transaction_finalized =
+			crate::BridgeRialtoPoA::verify_transaction_finalized(proof.block, proof.index, &proof.proof);
+
+		if !is_transaction_finalized {
+			return None;
+		}
+
+		proof.proof.get(proof.index as usize).map(|(tx, _)| tx.clone())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn genesis_hash_matches() {
+		assert_eq!(
+			genesis_header().compute_hash(),
+			hex!("1468e1a0fa20d30025a5a0f87e1cced4fdc393b84b7d2850b11ca5863db482cb").into(),
+		);
+	}
+
+	#[test]
+	fn pruning_strategy_keeps_enough_headers() {
+		assert_eq!(
+			PruningStrategy::default().pruning_upper_bound(100_000, 1_000),
+			0,
+			"1_000 <= 5_000 => nothing should be pruned yet",
+		);
+
+		assert_eq!(
+			PruningStrategy::default().pruning_upper_bound(100_000, 5_000),
+			0,
+			"5_000 <= 5_000 => nothing should be pruned yet",
+		);
+
+		assert_eq!(
+			PruningStrategy::default().pruning_upper_bound(100_000, 10_000),
+			5_000,
+			"5_000 <= 10_000 => we're ready to prune first 5_000 headers",
+		);
+	}
+}

polkadot/bridges/bin/runtime-common/Cargo.toml

@@ -0,0 +1,56 @@
+[package]
+name = "bridge-runtime-common"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+homepage = "https://substrate.dev"
+repository = "https://github.com/paritytech/parity-bridges-common/"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] }
+ed25519-dalek = { version = "1.0", default-features = false, optional = true }
+hash-db = { version = "0.15.2", default-features = false }
+
+# Bridge dependencies
+
+bp-message-dispatch = { path = "../../primitives/message-dispatch", default-features = false }
+bp-message-lane = { path = "../../primitives/message-lane", default-features = false }
+bp-runtime = { path = "../../primitives/runtime", default-features = false }
+pallet-bridge-call-dispatch = { path = "../../modules/call-dispatch", default-features = false }
+pallet-message-lane = { path = "../../modules/message-lane", default-features = false }
+pallet-substrate-bridge = { path = "../../modules/substrate", default-features = false }
+
+# Substrate dependencies
+
+frame-support = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-core = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-runtime = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-state-machine = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false, optional = true }
+sp-std = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+sp-trie = { git = "https://github.com/paritytech/substrate.git", branch = "master" , default-features = false }
+
+[features]
+default = ["std"]
+std = [
+	"bp-message-dispatch/std",
+	"bp-message-lane/std",
+	"bp-runtime/std",
+	"codec/std",
+	"frame-support/std",
+	"hash-db/std",
+	"pallet-bridge-call-dispatch/std",
+	"pallet-message-lane/std",
+	"pallet-substrate-bridge/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-trie/std",
+]
+runtime-benchmarks = [
+	"ed25519-dalek/u64_backend",
+	"pallet-message-lane/runtime-benchmarks",
+	"pallet-substrate-bridge/runtime-benchmarks",
+	"sp-state-machine",
+]

polkadot/bridges/bin/runtime-common/README.md

@@ -0,0 +1,183 @@
+# Helpers for Message Lane Module Integration
+
+The [`messages`](./src/messages.rs) module of this crate contains a bunch of helpers for integrating
+message lane module into your runtime. Basic prerequisites of these helpers are:
+- we're going to bridge Substrate-based chain with another Substrate-based chain;
+- both chains have [message lane module](../../modules/message-lane/README.md), Substrate bridge
+  module and the [call dispatch module](../../modules/call-dispatch/README.md);
+- all message lanes are identical and may be used to transfer the same messages;
+- the messages sent over the bridge are dispatched using
+  [call dispatch module](../../modules/call-dispatch/README.md);
+- the messages are `pallet_bridge_call_dispatch::MessagePayload` structures, where `call` field is
+  encoded `Call` of the target chain. This means that the `Call` is opaque to the
+  [message lane module](../../modules/message-lane/README.md) instance at the source chain.
+  It is pre-encoded by the message submitter;
+- all proofs in the [message lane module](../../modules/message-lane/README.md) transactions are
+  based on the storage proofs from the bridged chain: storage proof of the outbound message (value
+  from the `pallet_message_lane::Store::MessagePayload` map), storage proof of the outbound lane
+  state (value from the `pallet_message_lane::Store::OutboundLanes` map) and storage proof of the
+  inbound lane state (value from the `pallet_message_lane::Store::InboundLanes` map);
+- storage proofs are built at the finalized headers of the corresponding chain. So all message lane
+  transactions with proofs are verifying storage proofs against finalized chain headers from
+  Substrate bridge module.
+
+**IMPORTANT NOTE**: after reading this document, you may refer to our test runtimes
+([rialto_messages.rs](../millau/runtime/src/rialto_messages.rs) and/or
+[millau_messages.rs](../rialto/runtime/src/millau_messages.rs)) to see how to use these helpers.
+
+## Contents
+- [`MessageBridge` Trait](#messagebridge-trait)
+- [`ChainWithMessageLanes` Trait ](#chainwithmessagelanes-trait)
+- [Helpers for the Source Chain](#helpers-for-the-source-chain)
+- [Helpers for the Target Chain](#helpers-for-the-target-chain)
+
+## `MessageBridge` Trait
+
+The essence of your integration will be a struct that implements a `MessageBridge` trait. Let's
+review every method and give some implementation hints here:
+
+- `MessageBridge::maximal_extrinsic_size_on_target_chain`: you will need to return the maximal
+  extrinsic size of the target chain from this function. This may be the constant that is updated
+  when your runtime is upgraded, or you may use the
+  [message lane parameters functionality](../../modules/message-lane/README.md#Non-Essential-Functionality)
+  to allow the pallet owner to update this value more frequently (you may also want to use this
+  functionality for all constants that are used in other methods described below).
+
+- `MessageBridge::weight_limits_of_message_on_bridged_chain`: you'll need to return a range of
+  dispatch weights that the outbound message may take at the target chain. Please keep in mind that
+  our helpers assume that the message is an encoded call of the target chain. But we never decode
+  this call at the source chain. So you can't simply get dispatch weight from pre-dispatch
+  information. Instead there are two options to prepare this range: if you know which calls are to
+  be sent over your bridge, then you may just return weight ranges for these particular calls.
+  Otherwise, if you're going to accept all kinds of calls, you may just return range `[0; maximal
+  incoming message dispatch weight]`. If you choose the latter, then you shall remember that the
+  delivery transaction itself has some weight, so you can't accept messages with weight equal to
+  maximal weight of extrinsic at the target chain. In our test chains, we reject all messages that
+  have declared dispatch weight larger than 50% of the maximal bridged extrinsic weight.
+
+- `MessageBridge::weight_of_delivery_transaction`: you will need to return the maximal weight of the
+  delivery transaction that delivers a given message to the target chain. There are three main
+  things to notice:
+
+  1. weight, returned from this function is then used to compute the fee that the
+  message sender needs to pay for the delivery transaction. So it shall not be a simple dispatch
+  weight of delivery call - it should be the "weight" of the transaction itself, including per-byte
+  "weight", "weight" of signed extras and etc.
+  1. the delivery transaction brings storage proof of
+  the message, not the message itself. So your transaction will include extra bytes. We suggest
+  computing the size of single empty value storage proof at the source chain, increase this value a
+  bit and hardcode it in the source chain runtime code. This size then must be added to the size of
+  payload and included in the weight computation;
+  1. before implementing this function, please take
+  a look at the
+  [weight formula of delivery transaction](../../modules/message-lane/README.md#Weight-of-receive_messages_proof-call).
+  It adds some extra weight for every additional byte of the proof (everything above
+  `pallet_message_lane::EXPECTED_DEFAULT_MESSAGE_LENGTH`), so it's not trivial. Even better, please
+  refer to [our implementation](../millau/runtime/src/rialto_messages.rs) for test chains for
+  details.
+
+- `MessageBridge::weight_of_delivery_confirmation_transaction_on_this_chain`: you'll need to return
+  the maximal weight of a single message delivery confirmation transaction on this chain. All points
+  from the previous paragraph are also relevant here.
+
+- `MessageBridge::this_weight_to_this_balance`: this function needs to convert weight units into fee
+  units on this chain. Most probably this can be done by calling
+  `pallet_transaction_payment::Config::WeightToFee::calc()` for passed weight.
+
+- `MessageBridge::bridged_weight_to_bridged_balance`: this function needs to convert weight units
+  into fee units on the target chain. The best case is when you have the same conversion formula on
+  both chains - then you may just call the same formula from the previous paragraph. Otherwise,
+  you'll need to hardcode this formula into your runtime.
+
+- `MessageBridge::bridged_balance_to_this_balance`: this may be the easiest method to implement and
+  the hardest to maintain at the same time. If you don't have any automatic methods to determine
+  conversion rate, then you'll probably need to maintain it by yourself (by updating conversion
+  rate, stored in runtime storage). This means that if you're too late with an update, then you risk
+  to accept messages with lower-than-expected fee. So it may be wise to have some reserve in this
+  conversion rate, even if that means larger delivery and dispatch fees.
+
+## `ChainWithMessageLanes` Trait
+
+Apart from its methods, `MessageBridge` also has two associated types that are implementing the
+`ChainWithMessageLanes` trait. One is for this chain and the other is for the bridged chain. The
+trait is quite simple and can easily be implemented - you just need to specify types used at the
+corresponding chain. There are two exceptions, though. Both may be changed in the future. Here they
+are:
+
+- `ChainWithMessageLanes::Call`: it isn't a good idea to reference bridged chain runtime from your
+  runtime (cyclic references + maintaining on upgrades). So you can't know the type of bridged chain
+  call in your runtime. This type isn't actually used at this chain, so you may use `()` instead.
+
+- `ChainWithMessageLanes::MessageLaneInstance`: this is used to compute runtime storage keys. There
+  may be several instances of message lane pallet, included in the Runtime. Every instance stores
+  messages and these messages stored under different keys. When we are verifying storage proofs from
+  the bridged chain, we should know which instance we're talking to. This is fine, but there's
+  significant inconvenience with that - this chain runtime must have the same message lane pallet
+  instance. This does not necessarily mean that we should use the same instance on both chains -
+  this instance may be used to bridge with another chain/instance, or may not be used at all.
+
+## Helpers for the Source Chain
+
+The helpers for the Source Chain reside in the `source` submodule of the
+[`messages`](./src/messages.rs) module. The structs are: `FromThisChainMessagePayload`,
+`FromBridgedChainMessagesDeliveryProof`, `FromThisChainMessageVerifier`. And the helper functions
+are: `maximal_message_size`, `verify_chain_message`, `verify_messages_delivery_proof` and
+`estimate_message_dispatch_and_delivery_fee`.
+
+`FromThisChainMessagePayload` is a message that the sender sends through our bridge. It is the
+`pallet_bridge_call_dispatch::MessagePayload`, where `call` field is encoded target chain call. So
+at this chain we don't see internals of this call - we just know its size.
+
+`FromThisChainMessageVerifier` is an implementation of `bp_message_lane::LaneMessageVerifier`. It
+has following checks in its `verify_message` method:
+
+1. it'll verify that the used outbound lane is enabled in our runtime;
+
+1. it'll reject messages if there are too many undelivered outbound messages at this lane. The
+   sender need to wait while relayers will do their work before sending the message again;
+
+1. it'll reject a message if it has the wrong dispatch origin declared. Like if the submitter is not
+   the root of this chain, but it tries to dispatch the message at the target chain using
+   `pallet_bridge_call_dispatch::CallOrigin::SourceRoot` origin. Or he has provided wrong signature
+   in the `pallet_bridge_call_dispatch::CallOrigin::TargetAccount` origin;
+
+1. it'll reject a message if the delivery and dispatch fee that the submitter wants to pay is lesser
+   than the fee that is computed using the `estimate_message_dispatch_and_delivery_fee` function.
+
+`estimate_message_dispatch_and_delivery_fee` returns a minimal fee that the submitter needs to pay
+for sending a given message. The fee includes: payment for the delivery transaction at the target
+chain, payment for delivery confirmation transaction on this chain, payment for `Call` dispatch at
+the target chain and relayer interest.
+
+`FromBridgedChainMessagesDeliveryProof` holds the lane identifier and the storage proof of this
+inbound lane state at the bridged chain. This also holds the hash of the target chain header, that
+was used to generate this storage proof. The proof is verified by the
+`verify_messages_delivery_proof`, which simply checks that the target chain header is finalized
+(using Substrate bridge module) and then reads the inbound lane state from the proof.
+
+`verify_chain_message` function checks that the message may be delivered to the bridged chain. There
+are two main checks:
+
+1. that the message size is less than or equal to the `2/3` of maximal extrinsic size at the target
+   chain. We leave `1/3` for signed extras and for the storage proof overhead;
+
+1. that the message dispatch weight is less than or equal to the `1/2` of maximal normal extrinsic
+   weight at the target chain. We leave `1/2` for the delivery transaction overhead.
+
+## Helpers for the Target Chain
+
+The helpers for the target chain reside in the `target` submodule of the
+[`messages`](./src/messages.rs) module. The structs are: `FromBridgedChainMessagePayload`,
+`FromBridgedChainMessagesProof`, `FromBridgedChainMessagesProof`. And the helper functions are:
+`maximal_incoming_message_dispatch_weight`, `maximal_incoming_message_size` and
+`verify_messages_proof`.
+
+`FromBridgedChainMessagePayload` corresponds to the `FromThisChainMessagePayload` at the bridged
+chain. We expect that messages with this payload are stored in the `OutboundMessages` storage map of
+the [message lane module](../../modules/message-lane/README.md). This map is used to build
+`FromBridgedChainMessagesProof`. The proof holds the lane id, range of message nonces included in
+the proof, storage proof of `OutboundMessages` entries and the hash of bridged chain header that has
+been used to build the proof. Additionally, there's storage proof may contain the proof of outbound
+lane state. It may be required to prune `relayers` entries at this chain (see
+[message lane module documentation](../../modules/message-lane/README.md#What-about-other-Constants-in-the-Message-Lane-Module-Configuration-Trait)
+for details). This proof is verified by the `verify_messages_proof` function.

polkadot/bridges/bin/runtime-common/src/lib.rs

@@ -0,0 +1,22 @@
+// Copyright 2019-2020 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/>.
+
+//! Common types/functions that may be used by runtimes of all bridged chains.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod messages;
+pub mod messages_benchmarking;

polkadot/bridges/bin/runtime-common/src/messages_benchmarking.rs

@@ -0,0 +1,224 @@
+// Copyright 2019-2020 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/>.
+
+//! Everything required to run benchmarks of message-lanes, based on
+//! `bridge_runtime_common::messages` implementation.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::messages::{
+	source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, AccountIdOf, BalanceOf,
+	BridgedChain, HashOf, MessageBridge, ThisChain,
+};
+
+use bp_message_lane::{LaneId, MessageData, MessageKey, MessagePayload};
+use codec::Encode;
+use ed25519_dalek::{PublicKey, SecretKey, Signer, KEYPAIR_LENGTH, SECRET_KEY_LENGTH};
+use frame_support::weights::Weight;
+use pallet_message_lane::benchmarking::{MessageDeliveryProofParams, MessageProofParams, ProofSize};
+use sp_core::Hasher;
+use sp_runtime::traits::Header;
+use sp_std::prelude::*;
+use sp_trie::{record_all_keys, trie_types::TrieDBMut, Layout, MemoryDB, Recorder, TrieMut};
+
+/// Generate ed25519 signature to be used in `pallet_brdige_call_dispatch::CallOrigin::TargetAccount`.
+///
+/// Returns public key of the signer and the signature itself.
+pub fn ed25519_sign(target_call: &impl Encode, source_account_id: &impl Encode) -> ([u8; 32], [u8; 64]) {
+	// key from the repo example (https://docs.rs/ed25519-dalek/1.0.1/ed25519_dalek/struct.SecretKey.html)
+	let target_secret = SecretKey::from_bytes(&[
+		157, 097, 177, 157, 239, 253, 090, 096, 186, 132, 074, 244, 146, 236, 044, 196, 068, 073, 197, 105, 123, 050,
+		105, 025, 112, 059, 172, 003, 028, 174, 127, 096,
+	])
+	.expect("harcoded key is valid");
+	let target_public: PublicKey = (&target_secret).into();
+
+	let mut target_pair_bytes = [0u8; KEYPAIR_LENGTH];
+	target_pair_bytes[..SECRET_KEY_LENGTH].copy_from_slice(&target_secret.to_bytes());
+	target_pair_bytes[SECRET_KEY_LENGTH..].copy_from_slice(&target_public.to_bytes());
+	let target_pair = ed25519_dalek::Keypair::from_bytes(&target_pair_bytes).expect("hardcoded pair is valid");
+
+	let mut signature_message = Vec::new();
+	target_call.encode_to(&mut signature_message);
+	source_account_id.encode_to(&mut signature_message);
+	let target_origin_signature = target_pair
+		.try_sign(&signature_message)
+		.expect("Ed25519 try_sign should not fail in benchmarks");
+
+	(target_public.to_bytes(), target_origin_signature.to_bytes())
+}
+
+/// Prepare proof of messages for the `receive_messages_proof` call.
+pub fn prepare_message_proof<B, H, R, MM, ML, MH>(
+	params: MessageProofParams,
+	make_bridged_message_storage_key: MM,
+	make_bridged_outbound_lane_data_key: ML,
+	make_bridged_header: MH,
+	message_dispatch_weight: Weight,
+	message_payload: MessagePayload,
+) -> (FromBridgedChainMessagesProof<HashOf<BridgedChain<B>>>, Weight)
+where
+	B: MessageBridge,
+	H: Hasher,
+	R: pallet_substrate_bridge::Config,
+	<R::BridgedChain as bp_runtime::Chain>::Hash: Into<HashOf<BridgedChain<B>>>,
+	MM: Fn(MessageKey) -> Vec<u8>,
+	ML: Fn(LaneId) -> Vec<u8>,
+	MH: Fn(H::Out) -> <R::BridgedChain as bp_runtime::Chain>::Header,
+{
+	// prepare Bridged chain storage with messages and (optionally) outbound lane state
+	let message_count = params
+		.message_nonces
+		.end()
+		.saturating_sub(*params.message_nonces.start())
+		+ 1;
+	let mut storage_keys = Vec::with_capacity(message_count as usize + 1);
+	let mut root = Default::default();
+	let mut mdb = MemoryDB::default();
+	{
+		let mut trie = TrieDBMut::<H>::new(&mut mdb, &mut root);
+
+		// insert messages
+		for nonce in params.message_nonces.clone() {
+			let message_key = MessageKey {
+				lane_id: params.lane,
+				nonce,
+			};
+			let message_data = MessageData {
+				fee: BalanceOf::<BridgedChain<B>>::from(0),
+				payload: message_payload.clone(),
+			};
+			let storage_key = make_bridged_message_storage_key(message_key);
+			trie.insert(&storage_key, &message_data.encode())
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			storage_keys.push(storage_key);
+		}
+
+		// insert outbound lane state
+		if let Some(outbound_lane_data) = params.outbound_lane_data {
+			let storage_key = make_bridged_outbound_lane_data_key(params.lane);
+			trie.insert(&storage_key, &outbound_lane_data.encode())
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			storage_keys.push(storage_key);
+		}
+	}
+	root = grow_trie(root, &mut mdb, params.size);
+
+	// generate storage proof to be delivered to This chain
+	let mut proof_recorder = Recorder::<H::Out>::new();
+	record_all_keys::<Layout<H>, _>(&mdb, &root, &mut proof_recorder)
+		.map_err(|_| "record_all_keys has failed")
+		.expect("record_all_keys should not fail in benchmarks");
+	let storage_proof = proof_recorder.drain().into_iter().map(|n| n.data.to_vec()).collect();
+
+	// prepare Bridged chain header and insert it into the Substrate pallet
+	let bridged_header = make_bridged_header(root);
+	let bridged_header_hash = bridged_header.hash();
+	pallet_substrate_bridge::initialize_for_benchmarks::<R>(bridged_header);
+
+	(
+		FromBridgedChainMessagesProof {
+			bridged_header_hash: bridged_header_hash.into(),
+			storage_proof,
+			lane: params.lane,
+			nonces_start: *params.message_nonces.start(),
+			nonces_end: *params.message_nonces.end(),
+		},
+		message_dispatch_weight
+			.checked_mul(message_count)
+			.expect("too many messages requested by benchmark"),
+	)
+}
+
+/// Prepare proof of messages delivery for the `receive_messages_delivery_proof` call.
+pub fn prepare_message_delivery_proof<B, H, R, ML, MH>(
+	params: MessageDeliveryProofParams<AccountIdOf<ThisChain<B>>>,
+	make_bridged_inbound_lane_data_key: ML,
+	make_bridged_header: MH,
+) -> FromBridgedChainMessagesDeliveryProof<HashOf<BridgedChain<B>>>
+where
+	B: MessageBridge,
+	H: Hasher,
+	R: pallet_substrate_bridge::Config,
+	<R::BridgedChain as bp_runtime::Chain>::Hash: Into<HashOf<BridgedChain<B>>>,
+	ML: Fn(LaneId) -> Vec<u8>,
+	MH: Fn(H::Out) -> <R::BridgedChain as bp_runtime::Chain>::Header,
+{
+	// prepare Bridged chain storage with inbound lane state
+	let storage_key = make_bridged_inbound_lane_data_key(params.lane);
+	let mut root = Default::default();
+	let mut mdb = MemoryDB::default();
+	{
+		let mut trie = TrieDBMut::<H>::new(&mut mdb, &mut root);
+		trie.insert(&storage_key, &params.inbound_lane_data.encode())
+			.map_err(|_| "TrieMut::insert has failed")
+			.expect("TrieMut::insert should not fail in benchmarks");
+	}
+	root = grow_trie(root, &mut mdb, params.size);
+
+	// generate storage proof to be delivered to This chain
+	let mut proof_recorder = Recorder::<H::Out>::new();
+	record_all_keys::<Layout<H>, _>(&mdb, &root, &mut proof_recorder)
+		.map_err(|_| "record_all_keys has failed")
+		.expect("record_all_keys should not fail in benchmarks");
+	let storage_proof = proof_recorder.drain().into_iter().map(|n| n.data.to_vec()).collect();
+
+	// prepare Bridged chain header and insert it into the Substrate pallet
+	let bridged_header = make_bridged_header(root);
+	let bridged_header_hash = bridged_header.hash();
+	pallet_substrate_bridge::initialize_for_benchmarks::<R>(bridged_header);
+
+	FromBridgedChainMessagesDeliveryProof {
+		bridged_header_hash: bridged_header_hash.into(),
+		storage_proof,
+		lane: params.lane,
+	}
+}
+
+/// Populate trie with dummy keys+values until trie has at least given size.
+fn grow_trie<H: Hasher>(mut root: H::Out, mdb: &mut MemoryDB<H>, trie_size: ProofSize) -> H::Out {
+	let (iterations, leaf_size, minimal_trie_size) = match trie_size {
+		ProofSize::Minimal(_) => return root,
+		ProofSize::HasLargeLeaf(size) => (1, size, size),
+		ProofSize::HasExtraNodes(size) => (8, 1, size),
+	};
+
+	let mut key_index = 0;
+	loop {
+		// generate storage proof to be delivered to This chain
+		let mut proof_recorder = Recorder::<H::Out>::new();
+		record_all_keys::<Layout<H>, _>(mdb, &root, &mut proof_recorder)
+			.map_err(|_| "record_all_keys has failed")
+			.expect("record_all_keys should not fail in benchmarks");
+		let size: usize = proof_recorder.drain().into_iter().map(|n| n.data.len()).sum();
+		if size > minimal_trie_size as _ {
+			return root;
+		}
+
+		let mut trie = TrieDBMut::<H>::from_existing(mdb, &mut root)
+			.map_err(|_| "TrieDBMut::from_existing has failed")
+			.expect("TrieDBMut::from_existing should not fail in benchmarks");
+		for _ in 0..iterations {
+			trie.insert(&key_index.encode(), &vec![42u8; leaf_size as _])
+				.map_err(|_| "TrieMut::insert has failed")
+				.expect("TrieMut::insert should not fail in benchmarks");
+			key_index += 1;
+		}
+		trie.commit();
+	}
+}