Implement basic upward & downward messages (#118)

* Start by replacing branch names and set `DownwardMessage` * Add the upward-message crate * Add Kusama & Polkadot * More work on getting the upward messages working * Fix build * Begin to integrate it into the test Parachain * Update * Make everything compile again * Switch to westend and print parachain account on startup * Use MultiSignature etc * Fix validate block * Some downward messages work * Update git reference * More downward messages integration * Update test runtime for downward messages * Enable downward message handler and withdraw send tokens * Add some docs * Begin to implement simple XCMP * More work * Fixes and make parachain id configurable * Make parachain ID be part of the genesis * Finishing the XCMP message demo * Update and fixes tests * Update branch
2026-05-30 09:21:04 +00:00 · 2020-06-18 12:10:20 +02:00
parent 071d7a11c4
commit c9aaddf667
30 changed files with 1037 additions and 391 deletions
@@ -44,9 +44,11 @@ sc-finality-grandpa = { git = "https://github.com/paritytech/substrate", branch
 cumulus-consensus = { path = "../../consensus" }
 cumulus-collator = { path = "../../collator" }
 cumulus-network = { path = "../../network" }
+cumulus-primitives = { path = "../../primitives" }

 # Polkadot dependencies
 polkadot-primitives = { git = "https://github.com/paritytech/polkadot", branch = "cumulus-branch" }
+polkadot-parachain = { git = "https://github.com/paritytech/polkadot", branch = "cumulus-branch" }
 polkadot-collator = { git = "https://github.com/paritytech/polkadot", branch = "cumulus-branch" }
 polkadot-service = { git = "https://github.com/paritytech/polkadot", branch = "cumulus-branch" }
 polkadot-cli = { git = "https://github.com/paritytech/polkadot", branch = "cumulus-branch" }
@@ -70,8 +72,8 @@ polkadot-runtime = { git = "https://github.com/paritytech/polkadot", branch = "c
 # Substrate dependencies
 substrate-test-runtime-client = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 frame-system = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
+pallet-grandpa = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 pallet-transaction-payment = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 sp-arithmetic = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 sp-version = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
 pallet-sudo = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
-pallet-grandpa = { git = "https://github.com/paritytech/substrate", branch = "cumulus-branch" }
@@ -25,7 +25,6 @@ frame-support = { git = "https://github.com/paritytech/substrate", default-featu
 frame-executive = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
 frame-system = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
 pallet-balances = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
-pallet-indices = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
 pallet-randomness-collective-flip = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
 pallet-timestamp = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
 pallet-sudo = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "cumulus-branch" }
@@ -34,35 +33,48 @@ pallet-transaction-payment = { git = "https://github.com/paritytech/substrate",
 # Cumulus dependencies
 cumulus-runtime = { path = "../../../runtime", default-features = false }
 cumulus-parachain-upgrade = { path = "../../../parachain-upgrade", default-features = false }
+cumulus-message-broker = { path = "../../../message-broker", default-features = false }
+cumulus-upward-message = { path = "../../../upward-message", default-features = false }
+cumulus-primitives = { path = "../../../primitives", default-features = false }
+
+# Polkadot dependencies
+polkadot-parachain = { git = "https://github.com/paritytech/polkadot", branch = "cumulus-branch", default-features = false }

 [build-dependencies]
 wasm-builder-runner = { package = "substrate-wasm-builder-runner", version = "1.0.6" }

 [features]
-default = ['std']
+default = [ "std" ]
 std = [
-	'codec/std',
-	'serde',
-	'sp-api/std',
-	'sp-std/std',
-	'sp-io/std',
-	'sp-core/std',
-	'sp-runtime/std',
-	'sp-version/std',
-	'sp-offchain/std',
-	'sp-session/std',
-	'sp-block-builder/std',
-	'sp-transaction-pool/std',
-	'sp-inherents/std',
-	'frame-support/std',
-	'frame-executive/std',
-	'frame-system/std',
-	'pallet-balances/std',
-	'pallet-indices/std',
-	'pallet-randomness-collective-flip/std',
-	'pallet-timestamp/std',
-	'pallet-sudo/std',
-	'pallet-transaction-payment/std',
-	'cumulus-runtime/std',
-	'cumulus-parachain-upgrade/std',
+	"codec/std",
+	"serde",
+	"sp-api/std",
+	"sp-std/std",
+	"sp-io/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-version/std",
+	"sp-offchain/std",
+	"sp-session/std",
+	"sp-block-builder/std",
+	"sp-transaction-pool/std",
+	"sp-inherents/std",
+	"frame-support/std",
+	"frame-executive/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-randomness-collective-flip/std",
+	"pallet-timestamp/std",
+	"pallet-sudo/std",
+	"pallet-transaction-payment/std",
+	"cumulus-runtime/std",
+	"cumulus-parachain-upgrade/std",
+	"cumulus-message-broker/std",
+	"cumulus-upward-message/std",
+	"cumulus-primitives/std",
+	"polkadot-parachain/std",
+]
+# Will be enabled by the `wasm-builder` when building the runtime for WASM.
+runtime-wasm = [
+	"cumulus-upward-message/runtime-wasm",
 ]
@@ -26,20 +26,22 @@ use sp_api::impl_runtime_apis;
 use sp_core::OpaqueMetadata;
 use sp_runtime::{
 	create_runtime_str, generic, impl_opaque_keys,
-	traits::{BlakeTwo256, Block as BlockT, Saturating, StaticLookup, Verify},
+	traits::{BlakeTwo256, Block as BlockT, IdentifyAccount, IdentityLookup, Saturating, Verify},
 	transaction_validity::{TransactionSource, TransactionValidity},
-	AnySignature, ApplyExtrinsicResult,
+	ApplyExtrinsicResult, MultiSignature,
 };
 use sp_std::prelude::*;
 #[cfg(feature = "std")]
 use sp_version::NativeVersion;
 use sp_version::RuntimeVersion;

+mod message_example;
+
 // A few exports that help ease life for downstream crates.
 pub use frame_support::{
 	construct_runtime, parameter_types,
 	traits::Randomness,
-	weights::{IdentityFee, Weight},
+	weights::{constants::WEIGHT_PER_SECOND, IdentityFee, Weight},
 	StorageValue,
 };
 pub use pallet_balances::Call as BalancesCall;
@@ -52,11 +54,11 @@ pub use sp_runtime::{Perbill, Permill};
 pub type BlockNumber = u32;

 /// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
-pub type Signature = AnySignature;
+pub type Signature = MultiSignature;

 /// 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 = <Signature as Verify>::Signer;
+pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;

 /// The type for looking up accounts. We don't expect more than 4 billion of them, but you
 /// never know...
@@ -122,6 +124,12 @@ pub const DAYS: BlockNumber = HOURS * 24;
 // 1 in 4 blocks (on average, not counting collisions) will be primary babe blocks.
 pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4);

+#[derive(codec::Encode, codec::Decode)]
+pub enum XCMPMessage<XAccountId, XBalance> {
+	/// Transfer tokens to the given account from the Parachain account.
+	TransferToken(XAccountId, XBalance),
+}
+
 /// The version infromation used to identify this runtime when compiled natively.
 #[cfg(feature = "std")]
 pub fn native_version() -> NativeVersion {
@@ -133,7 +141,7 @@ pub fn native_version() -> NativeVersion {

 parameter_types! {
 	pub const BlockHashCount: BlockNumber = 250;
-	pub const MaximumBlockWeight: Weight = 1_000_000;
+	pub const MaximumBlockWeight: Weight = 2 * WEIGHT_PER_SECOND;
 	/// Assume 10% of weight for average on_initialize calls.
 	pub MaximumExtrinsicWeight: Weight = AvailableBlockRatio::get()
 		.saturating_sub(Perbill::from_percent(10)) * MaximumBlockWeight::get();
@@ -149,7 +157,7 @@ impl frame_system::Trait for Runtime {
 	/// 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 = Indices;
+	type Lookup = IdentityLookup<AccountId>;
 	/// The index type for storing how many extrinsics an account has signed.
 	type Index = Index;
 	/// The index type for blocks.
@@ -178,24 +186,13 @@ impl frame_system::Trait for Runtime {
 	type ModuleToIndex = ModuleToIndex;
 	type AccountData = pallet_balances::AccountData<Balance>;
 	type OnNewAccount = ();
-	type OnKilledAccount = Balances;
+	type OnKilledAccount = ();
 	type DbWeight = ();
 	type ExtrinsicBaseWeight = ExtrinsicBaseWeight;
 	type BlockExecutionWeight = ();
 	type MaximumExtrinsicWeight = MaximumExtrinsicWeight;
 }

-parameter_types! {
-	pub const IndexDeposit: Balance = 1;
-}
-
-impl pallet_indices::Trait for Runtime {
-	type AccountIndex = u32;
-	type Event = Event;
-	type Currency = Balances;
-	type Deposit = IndexDeposit;
-}
-
 parameter_types! {
 	pub const MinimumPeriod: u64 = SLOT_DURATION / 2;
 }
@@ -242,6 +239,27 @@ impl cumulus_parachain_upgrade::Trait for Runtime {
 	type OnValidationFunctionParams = ();
 }

+parameter_types! {
+	pub storage ParachainId: cumulus_primitives::ParaId = 100.into();
+}
+
+impl cumulus_message_broker::Trait for Runtime {
+	type Event = Event;
+	type DownwardMessageHandlers = TokenDealer;
+	type UpwardMessage = cumulus_upward_message::WestendUpwardMessage;
+	type ParachainId = ParachainId;
+	type XCMPMessage = XCMPMessage<AccountId, Balance>;
+	type XCMPMessageHandlers = TokenDealer;
+}
+
+impl message_example::Trait for Runtime {
+	type Event = Event;
+	type UpwardMessageSender = MessageBroker;
+	type UpwardMessage = cumulus_upward_message::WestendUpwardMessage;
+	type Currency = Balances;
+	type XCMPMessageSender = MessageBroker;
+}
+
 construct_runtime! {
 	pub enum Runtime where
 		Block = Block,
@@ -250,16 +268,18 @@ construct_runtime! {
 	{
 		System: frame_system::{Module, Call, Storage, Config, Event<T>},
 		Timestamp: pallet_timestamp::{Module, Call, Storage, Inherent},
-		Indices: pallet_indices::{Module, Call, Storage, Config<T>, Event<T>},
 		Balances: pallet_balances::{Module, Call, Storage, Config<T>, Event<T>},
 		Sudo: pallet_sudo::{Module, Call, Storage, Config<T>, Event<T>},
 		RandomnessCollectiveFlip: pallet_randomness_collective_flip::{Module, Call, Storage},
 		ParachainUpgrade: cumulus_parachain_upgrade::{Module, Call, Storage, Inherent, Event},
+		MessageBroker: cumulus_message_broker::{Module, Call, Inherent, Event<T>},
+		TokenDealer: message_example::{Module, Call, Event<T>, Config},
+		TransactionPayment: pallet_transaction_payment::{Module, Storage},
 	}
 }

 /// The address format for describing accounts.
-pub type Address = <Indices as StaticLookup>::Source;
+pub type Address = AccountId;
 /// Block header type as expected by this runtime.
 pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
 /// Block type as expected by this runtime.
@@ -0,0 +1,179 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Cumulus.
+
+// Cumulus 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.
+
+// Cumulus 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 Cumulus.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Example Pallet that shows how to send upward messages and how to receive
+//! downward messages.
+
+use frame_support::{
+	decl_event, decl_module, decl_storage,
+	traits::{Currency, ExistenceRequirement, WithdrawReason},
+};
+use frame_system::ensure_signed;
+
+use crate::XCMPMessage;
+use codec::{Decode, Encode};
+use cumulus_primitives::{
+	relay_chain::DownwardMessage,
+	xcmp::{XCMPMessageHandler, XCMPMessageSender},
+	DownwardMessageHandler, ParaId, UpwardMessageOrigin, UpwardMessageSender,
+};
+use cumulus_upward_message::BalancesMessage;
+use polkadot_parachain::primitives::AccountIdConversion;
+use sp_runtime::DispatchResult;
+
+type BalanceOf<T> =
+	<<T as Trait>::Currency as Currency<<T as frame_system::Trait>::AccountId>>::Balance;
+
+/// Configuration trait of this pallet.
+pub trait Trait: frame_system::Trait {
+	/// Event type used by the runtime.
+	type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;
+
+	/// The sender of upward messages.
+	type UpwardMessageSender: UpwardMessageSender<Self::UpwardMessage>;
+
+	/// The upward message type used by the Parachain runtime.
+	type UpwardMessage: codec::Codec + BalancesMessage<Self::AccountId, BalanceOf<Self>>;
+
+	/// Currency of the runtime.
+	type Currency: Currency<Self::AccountId>;
+
+	/// The sender of XCMP messages.
+	type XCMPMessageSender: XCMPMessageSender<XCMPMessage<Self::AccountId, BalanceOf<Self>>>;
+}
+
+// This pallet's storage items.
+decl_storage! {
+	trait Store for Module<T: Trait> as ParachainUpgrade {}
+	add_extra_genesis {
+		config(parachain_id): ParaId;
+		build(|config: &Self| {
+			// This is basically a hack to make the parachain id easily configurable.
+			// Could also be done differently, but yeah..
+			crate::ParachainId::set(&config.parachain_id);
+		});
+	}
+}
+
+decl_event! {
+	pub enum Event<T> where
+		AccountId = <T as frame_system::Trait>::AccountId,
+		Balance = BalanceOf<T>
+	{
+		/// Transferred tokens to the account on the relay chain.
+		TransferredTokensToRelayChain(AccountId, Balance),
+		/// Transferred tokens to the account on request from the relay chain.
+		TransferredTokensFromRelayChain(AccountId, Balance),
+		/// Transferred tokens to the account from the given parachain account.
+		TransferredTokensViaXCMP(ParaId, AccountId, Balance, DispatchResult),
+	}
+}
+
+decl_module! {
+	pub struct Module<T: Trait> for enum Call where origin: T::Origin, system = frame_system {
+		/// Transfer `amount` of tokens on the relay chain from the Parachain account to
+		/// the given `dest` account.
+		#[weight = 10]
+		fn transfer_tokens_to_relay_chain(origin, dest: T::AccountId, amount: BalanceOf<T>) {
+			let who = ensure_signed(origin)?;
+
+			let _ = T::Currency::withdraw(
+				&who,
+				amount,
+				WithdrawReason::Transfer.into(),
+				ExistenceRequirement::AllowDeath,
+			)?;
+
+			let msg = <T as Trait>::UpwardMessage::transfer(dest.clone(), amount.clone());
+			<T as Trait>::UpwardMessageSender::send_upward_message(&msg, UpwardMessageOrigin::Signed)
+				.expect("Should not fail; qed");
+
+			Self::deposit_event(Event::<T>::TransferredTokensToRelayChain(dest, amount));
+		}
+
+		/// Transfer `amount` of tokens to another parachain.
+		#[weight = 10]
+		fn transfer_tokens_to_parachain_chain(
+			origin,
+			para_id: u32,
+			dest: T::AccountId,
+			amount: BalanceOf<T>,
+		) {
+			//TODO we don't make sure that the parachain has some tokens on the other parachain.
+			let who = ensure_signed(origin)?;
+
+			let _ = T::Currency::withdraw(
+				&who,
+				amount,
+				WithdrawReason::Transfer.into(),
+				ExistenceRequirement::AllowDeath,
+			)?;
+
+			T::XCMPMessageSender::send_xcmp_message(
+				para_id.into(),
+				&XCMPMessage::TransferToken(dest, amount),
+			).expect("Should not fail; qed");
+		}
+
+		fn deposit_event() = default;
+	}
+}
+
+/// This is a hack to convert from one generic type to another where we are sure that both are the
+/// same type/use the same encoding.
+fn convert_hack<O: Decode>(input: &impl Encode) -> O {
+	input.using_encoded(|e| Decode::decode(&mut &e[..]).expect("Must be compatible; qed"))
+}
+
+impl<T: Trait> DownwardMessageHandler for Module<T> {
+	fn handle_downward_message(msg: &DownwardMessage) {
+		match msg {
+			DownwardMessage::TransferInto(dest, amount, _) => {
+				let dest = convert_hack(&dest);
+				let amount: BalanceOf<T> = convert_hack(amount);
+
+				let _ = T::Currency::deposit_creating(&dest, amount.clone());
+
+				Self::deposit_event(Event::<T>::TransferredTokensFromRelayChain(dest, amount));
+			}
+			_ => {}
+		}
+	}
+}
+
+impl<T: Trait> XCMPMessageHandler<XCMPMessage<T::AccountId, BalanceOf<T>>> for Module<T> {
+	fn handle_xcmp_message(src: ParaId, msg: &XCMPMessage<T::AccountId, BalanceOf<T>>) {
+		match msg {
+			XCMPMessage::TransferToken(dest, amount) => {
+				let para_account = src.clone().into_account();
+
+				let res = T::Currency::transfer(
+					&para_account,
+					dest,
+					amount.clone(),
+					ExistenceRequirement::AllowDeath,
+				);
+
+				Self::deposit_event(Event::<T>::TransferredTokensViaXCMP(
+					src,
+					dest.clone(),
+					amount.clone(),
+					res,
+				));
+			}
+		}
+	}
+}
@@ -14,11 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.

+use cumulus_primitives::ParaId;
 use parachain_runtime::{
-	AccountId, BalancesConfig, GenesisConfig, IndicesConfig, SudoConfig, SystemConfig, WASM_BINARY,
+	AccountId, BalancesConfig, GenesisConfig, Signature, SudoConfig, SystemConfig,
+	TokenDealerConfig, WASM_BINARY,
 };
-use sc_service;
-use sp_core::{Pair, Public};
+use sc_service::ChainType;
+use sp_core::{sr25519, Pair, Public};
+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>;
@@ -30,42 +33,39 @@ pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Pu
 		.public()
 }

-/// Helper function to generate stash, controller and session key from seed
-pub fn get_authority_keys_from_seed(seed: &str) -> (AccountId, AccountId) {
-	(
-		get_from_seed::<AccountId>(&format!("{}//stash", seed)),
-		get_from_seed::<AccountId>(seed),
-	)
+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()
 }

-/// Returns the chain spec.
-pub fn get_chain_spec() -> ChainSpec {
+pub fn get_chain_spec(id: ParaId) -> ChainSpec {
 	ChainSpec::from_genesis(
 		"Local Testnet",
-		"parachain_local_testnet",
-		sc_service::ChainType::Local,
-		|| {
+		"local_testnet",
+		ChainType::Local,
+		move || {
 			testnet_genesis(
+				get_account_id_from_seed::<sr25519::Public>("Alice"),
 				vec![
-					get_authority_keys_from_seed("Alice"),
-					get_authority_keys_from_seed("Bob"),
+					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>("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_from_seed::<AccountId>("Alice"),
-				vec![
-					get_from_seed::<AccountId>("Alice"),
-					get_from_seed::<AccountId>("Bob"),
-					get_from_seed::<AccountId>("Charlie"),
-					get_from_seed::<AccountId>("Dave"),
-					get_from_seed::<AccountId>("Eve"),
-					get_from_seed::<AccountId>("Ferdie"),
-					get_from_seed::<AccountId>("Alice//stash"),
-					get_from_seed::<AccountId>("Bob//stash"),
-					get_from_seed::<AccountId>("Charlie//stash"),
-					get_from_seed::<AccountId>("Dave//stash"),
-					get_from_seed::<AccountId>("Eve//stash"),
-					get_from_seed::<AccountId>("Ferdie//stash"),
-				],
-				true,
+				id,
 			)
 		},
 		vec![],
@@ -77,19 +77,15 @@ pub fn get_chain_spec() -> ChainSpec {
 }

 fn testnet_genesis(
-	_initial_authorities: Vec<(AccountId, AccountId)>,
 	root_key: AccountId,
 	endowed_accounts: Vec<AccountId>,
-	_enable_println: bool,
+	id: ParaId,
 ) -> GenesisConfig {
 	GenesisConfig {
 		frame_system: Some(SystemConfig {
 			code: WASM_BINARY.to_vec(),
 			changes_trie_config: Default::default(),
 		}),
-		pallet_indices: Some(IndicesConfig {
-			indices: vec![],
-		}),
 		pallet_balances: Some(BalancesConfig {
 			balances: endowed_accounts
 				.iter()
@@ -98,5 +94,6 @@ fn testnet_genesis(
 				.collect(),
 		}),
 		pallet_sudo: Some(SudoConfig { key: root_key }),
+		message_example: Some(TokenDealerConfig { parachain_id: id }),
 	}
 }
@@ -42,6 +42,28 @@ pub struct ExportGenesisStateCommand {
 	/// Output file name or stdout if unspecified.
 	#[structopt(parse(from_os_str))]
 	pub output: Option<PathBuf>,
+
+	/// Id of the parachain this state is for.
+	#[structopt(long, default_value = "100")]
+	pub parachain_id: u32,
+}
+
+#[derive(Debug, StructOpt)]
+pub struct RunCmd {
+	#[structopt(flatten)]
+	pub base: sc_cli::RunCmd,
+
+	/// Id of the parachain this collator collates for.
+	#[structopt(long, default_value = "100")]
+	pub parachain_id: u32,
+}
+
+impl std::ops::Deref for RunCmd {
+	type Target = sc_cli::RunCmd;
+
+	fn deref(&self) -> &Self::Target {
+		&self.base
+	}
 }

 #[derive(Debug, StructOpt)]
@@ -55,7 +77,7 @@ pub struct Cli {
 	pub subcommand: Option<Subcommand>,

 	#[structopt(flatten)]
-	pub run: sc_cli::RunCmd,
+	pub run: RunCmd,

 	/// Relaychain arguments
 	#[structopt(raw = true)]
@@ -19,6 +19,7 @@ use crate::cli::{Cli, PolkadotCli, Subcommand};
 use codec::Encode;
 use log::info;
 use parachain_runtime::Block;
+use polkadot_parachain::primitives::AccountIdConversion;
 use sc_cli::{
 	CliConfiguration, Error, ImportParams, KeystoreParams, NetworkParams, Result, SharedParams,
 	SubstrateCli,
@@ -30,8 +31,8 @@ use sp_runtime::{
 	traits::{Block as BlockT, Hash as HashT, Header as HeaderT, Zero},
 	BuildStorage,
 };
-use std::net::SocketAddr;
-use std::sync::Arc;
+use std::{net::SocketAddr, sync::Arc};
+use cumulus_primitives::ParaId;

 impl SubstrateCli for Cli {
 	fn impl_name() -> &'static str {
@@ -66,7 +67,8 @@ impl SubstrateCli for Cli {
 	}

 	fn load_spec(&self, _id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
-		Ok(Box::new(chain_spec::get_chain_spec()))
+		// Such a hack :(
+		Ok(Box::new(chain_spec::get_chain_spec(self.run.parachain_id.into())))
 	}
 }

@@ -114,23 +116,21 @@ impl SubstrateCli for PolkadotCli {
 	}
 }

-fn generate_genesis_state() -> Result<Block> {
-	let storage = (&chain_spec::get_chain_spec()).build_storage()?;
+fn generate_genesis_state(para_id: ParaId) -> Result<Block> {
+	let storage = (&chain_spec::get_chain_spec(para_id)).build_storage()?;

 	let child_roots = storage.children_default.iter().map(|(sk, child_content)| {
-		let state_root =
-			<<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
-				child_content.data.clone().into_iter().collect(),
-			);
+		let state_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+			child_content.data.clone().into_iter().collect(),
+		);
 		(sk.clone(), state_root.encode())
 	});
 	let state_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
 		storage.top.clone().into_iter().chain(child_roots).collect(),
 	);

-	let extrinsics_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
-		Vec::new(),
-	);
+	let extrinsics_root =
+		<<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(Vec::new());

 	Ok(Block::new(
 		<<Block as BlockT>::Header as HeaderT>::new(
@@ -157,7 +157,7 @@ pub fn run() -> Result<()> {
 		Some(Subcommand::ExportGenesisState(params)) => {
 			sc_cli::init_logger("");

-			let block = generate_genesis_state()?;
+			let block = generate_genesis_state(params.parachain_id.into())?;
 			let header_hex = format!("0x{:?}", HexDisplay::from(&block.header().encode()));

 			if let Some(output) = &params.output {
@@ -174,13 +174,14 @@ pub fn run() -> Result<()> {
 			let grandpa_pause = if polkadot_cli.run.grandpa_pause.is_empty() {
 				None
 			} else {
-				Some((polkadot_cli.run.grandpa_pause[0], polkadot_cli.run.grandpa_pause[1]))
+				Some((
+					polkadot_cli.run.grandpa_pause[0],
+					polkadot_cli.run.grandpa_pause[1],
+				))
 			};

 			runner.run_node(
-				|config| {
-					polkadot_service::polkadot_new_light(config)
-				},
+				|config| polkadot_service::polkadot_new_light(config),
 				|config| {
 					polkadot_service::polkadot_new_full(
 						config,
@@ -190,22 +191,23 @@ pub fn run() -> Result<()> {
 						6000,
 						grandpa_pause,
 						None,
-					).map(|(s, _, _)| s)
+					)
+					.map(|(s, _, _)| s)
 				},
-				polkadot_service::PolkadotExecutor::native_version().runtime_version
+				polkadot_service::PolkadotExecutor::native_version().runtime_version,
 			)
-		},
+		}
 		Some(Subcommand::PolkadotValidationWorker(cmd)) => {
 			sc_cli::init_logger("");
 			polkadot_service::run_validation_worker(&cmd.mem_id)?;

 			Ok(())
-		},
+		}
 		None => {
-			let runner = cli.create_runner(&cli.run)?;
+			let runner = cli.create_runner(&*cli.run)?;

 			// TODO
-			let key = Arc::new(sp_core::Pair::from_seed(&[10; 32]));
+			let key = Arc::new(sp_core::Pair::generate().0);

 			let mut polkadot_cli = PolkadotCli::from_iter(
 				[PolkadotCli::executable_name().to_string()]
@@ -213,6 +215,14 @@ pub fn run() -> Result<()> {
 					.chain(cli.relaychain_args.iter()),
 			);

+			let id = ParaId::from(cli.run.parachain_id);
+
+			let parachain_account =
+				AccountIdConversion::<polkadot_primitives::AccountId>::into_account(&id);
+
+			let block = generate_genesis_state(id)?;
+			let genesis_state = format!("0x{:?}", HexDisplay::from(&block.header().encode()));
+
 			runner.run_full_node(
 				|config| {
 					polkadot_cli.base_path =
@@ -226,9 +236,11 @@ pub fn run() -> Result<()> {
 					)
 					.unwrap();

-					info!("Parachain id: {:?}", crate::PARA_ID);
+					info!("Parachain id: {:?}", id);
+					info!("Parachain Account: {}", parachain_account);
+					info!("Parachain genesis state: {}", genesis_state);

-					crate::service::run_collator(config, key, polkadot_config)
+					crate::service::run_collator(config, key, polkadot_config, id)
 				},
 				parachain_runtime::VERSION,
 			)
@@ -19,17 +19,12 @@
 #![warn(missing_docs)]
 #![warn(unused_extern_crates)]

-use polkadot_primitives::parachain::Id as ParaId;
-
 mod chain_spec;
 #[macro_use]
 mod service;
 mod cli;
 mod command;

-/// The parachain id of this parachain.
-pub const PARA_ID: ParaId = ParaId::new(100);
-
 fn main() -> sc_cli::Result<()> {
 	command::run()
 }
@@ -15,15 +15,17 @@
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.

 use ansi_term::Color;
-use std::sync::Arc;
-use sc_executor::native_executor_instance;
-use sc_service::{AbstractService, Configuration};
-use sc_finality_grandpa::{FinalityProofProvider as GrandpaFinalityProofProvider, StorageAndProofProvider};
-use polkadot_primitives::parachain::CollatorPair;
-use cumulus_collator::{CollatorBuilder, prepare_collator_config};
-use futures::FutureExt;
-pub use sc_executor::NativeExecutor;
+use cumulus_collator::{prepare_collator_config, CollatorBuilder};
 use cumulus_network::DelayedBlockAnnounceValidator;
+use futures::FutureExt;
+use polkadot_primitives::parachain::CollatorPair;
+use sc_executor::native_executor_instance;
+pub use sc_executor::NativeExecutor;
+use sc_finality_grandpa::{
+	FinalityProofProvider as GrandpaFinalityProofProvider, StorageAndProofProvider,
+};
+use sc_service::{AbstractService, Configuration};
+use std::sync::Arc;

 // Our native executor instance.
 native_executor_instance!(
@@ -47,9 +49,8 @@ macro_rules! new_full_start {
 		>($config)?
 		.with_select_chain(|_config, backend| Ok(sc_consensus::LongestChain::new(backend.clone())))?
 		.with_transaction_pool(|builder| {
-			let pool_api = Arc::new(sc_transaction_pool::FullChainApi::new(
-				builder.client().clone(),
-			));
+			let client = builder.client();
+			let pool_api = Arc::new(sc_transaction_pool::FullChainApi::new(client.clone()));
 			let pool = sc_transaction_pool::BasicPool::new(
 				builder.config().transaction_pool.clone(),
 				pool_api,
@@ -57,19 +58,12 @@ macro_rules! new_full_start {
 			);
 			Ok(pool)
 		})?
-		.with_import_queue(|
-			_config,
-			client,
-			_,
-			_,
-			spawn_task_handle,
-			registry,
-		| {
+		.with_import_queue(|_config, client, _, _, spawner, registry| {
 			let import_queue = cumulus_consensus::import_queue::import_queue(
 				client.clone(),
 				client,
 				inherent_data_providers.clone(),
-				spawn_task_handle,
+				spawner,
 				registry,
 			)?;

@@ -87,6 +81,7 @@ pub fn run_collator(
 	parachain_config: Configuration,
 	key: Arc<CollatorPair>,
 	polkadot_config: polkadot_collator::Configuration,
+	id: polkadot_primitives::parachain::Id,
 ) -> sc_service::error::Result<impl AbstractService> {
 	let parachain_config = prepare_collator_config(parachain_config);

@@ -104,9 +99,7 @@ pub fn run_collator(
 			let provider = client as Arc<dyn StorageAndProofProvider<_, _>>;
 			Ok(Arc::new(GrandpaFinalityProofProvider::new(backend, provider)) as _)
 		})?
-		.with_block_announce_validator(|_client| {
-			Box::new(block_announce_validator_copy)
-		})?
+		.with_block_announce_validator(|_client| Box::new(block_announce_validator_copy))?
 		.build_full()?;

 	let registry = service.prometheus_registry();
@@ -120,14 +113,12 @@ pub fn run_collator(
 	let block_import = service.client();
 	let client = service.client();
 	let network = service.network();
-	let announce_block = Arc::new(move |hash, data| {
-		network.announce_block(hash, data)
-	});
+	let announce_block = Arc::new(move |hash, data| network.announce_block(hash, data));
 	let builder = CollatorBuilder::new(
 		proposer_factory,
 		inherent_data_providers,
 		block_import,
-		crate::PARA_ID,
+		id,
 		client,
 		announce_block,
 		block_announce_validator,
@@ -135,11 +126,12 @@ pub fn run_collator(

 	let polkadot_future = polkadot_collator::start_collator(
 		builder,
-		crate::PARA_ID,
+		id,
 		key,
 		polkadot_config,
 		Some(format!("[{}] ", Color::Blue.bold().paint("Relaychain"))),
-	).map(|_| ());
+	)
+	.map(|_| ());
 	service.spawn_essential_task("polkadot", polkadot_future);

 	Ok(service)
@@ -48,6 +48,6 @@ fn purge_chain_works() {
 	assert!(status.success());

 	// Make sure that the `parachain_local_testnet` chain folder exists, but the `db` is deleted.
-	assert!(PathBuf::from(base_path).join("chains/parachain_local_testnet/").exists());
-	assert!(!PathBuf::from(base_path).join("chains/parachain_local_testnet/db").exists());
+	assert!(PathBuf::from(base_path).join("chains/local_testnet/").exists());
+	assert!(!PathBuf::from(base_path).join("chains/local_testnet/db").exists());
 }