port test-parachains

collator/src/lib.rs

@@ -59,7 +59,7 @@ use polkadot_primitives::{
 	BlockId, Hash, Block,
 	parachain::{
 		self, BlockData, DutyRoster, HeadData, Id as ParaId,
-		PoVBlock, ValidatorId, CollatorPair, LocalValidationData
+		PoVBlock, ValidatorId, CollatorPair, LocalValidationData, GlobalValidationSchedule,
 	}
 };
 use polkadot_cli::{
@@ -154,14 +154,16 @@ pub trait ParachainContext: Clone {
 	fn produce_candidate(
 		&mut self,
 		relay_parent: Hash,
-		status: LocalValidationData,
+		global_validation: GlobalValidationSchedule,
+		local_validation: LocalValidationData,
 	) -> Self::ProduceCandidate;
 }
 
 /// Produce a candidate for the parachain, with given contexts, parent head, and signing key.
 pub async fn collate<P>(
 	relay_parent: Hash,
 	local_id: ParaId,
+	global_validation: GlobalValidationSchedule,
 	local_validation_data: LocalValidationData,
 	mut para_context: P,
 	key: Arc<CollatorPair>,
@@ -173,6 +175,7 @@ pub async fn collate<P>(
 {
 	let (block_data, head_data) = para_context.produce_candidate(
 		relay_parent,
+		global_validation,
 		local_validation_data,
 	).map_err(Error::Collator).await?;
 
@@ -281,6 +284,7 @@ fn build_collator_service<S, P, Extrinsic>(
 
 			let work = future::lazy(move |_| {
 				let api = client.runtime_api();
+				let global_validation = try_fr!(api.global_validation_schedule(&id));
 				let local_validation = match try_fr!(api.local_validation_data(&id, para_id)) {
 					Some(local_validation) => local_validation,
 					None => return future::Either::Left(future::ok(())),
@@ -297,6 +301,7 @@ fn build_collator_service<S, P, Extrinsic>(
 				let collation_work = collate(
 					relay_parent,
 					para_id,
+					global_validation,
 					local_validation,
 					parachain_context,
 					key,

parachain/Cargo.toml

@@ -12,12 +12,12 @@ edition = "2018"
 codec = { package = "parity-scale-codec", version = "1.1.0", default-features = false, features = [ "derive" ] }
 rstd = { package = "sp-std", git = "https://github.com/paritytech/substrate", branch = "polkadot-master", default-features = false }
 sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", default-features = false }
-sp-runtime-interface = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", default-features = false }
 sp-wasm-interface = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", default-features = false }
 
 # all optional crates.
 derive_more = { version = "0.99.2", optional = true }
 serde = { version = "1.0.102", default-features = false, features = [ "derive" ], optional = true }
+sp-runtime-interface = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", optional = true, default-features = false }
 sp-externalities = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", optional = true }
 sc-executor = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", optional = true }
 sp-io = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master", optional = true }
@@ -35,7 +35,7 @@ halt = { path = "../test-parachains/halt" }
 
 [features]
 default = ["std"]
-wasm-api = []
+wasm-api = ["sp-runtime-interface"]
 std = [
 	"codec/std",
 	"derive_more",

parachain/src/primitives.rs

@@ -173,7 +173,8 @@ impl rstd::convert::TryFrom<u8> for ParachainDispatchOrigin {
 }
 
 /// A message from a parachain to its Relay Chain.
-#[derive(Clone, PartialEq, Eq, Encode, Decode, sp_runtime_interface::pass_by::PassByCodec)]
+#[derive(Clone, PartialEq, Eq, Encode, Decode)]
+#[cfg_attr(feature = "wasm-api", derive(sp_runtime_interface::pass_by::PassByCodec))]
 #[cfg_attr(feature = "std", derive(Debug))]
 pub struct UpwardMessage {
 	/// The origin for the message to be sent from.

parachain/src/wasm_api.rs

@@ -16,7 +16,9 @@
 
 //! Utilities for writing parachain WASM.
 
+#[cfg(any(feature = "std", all(not(feature = "std"), feature = "wasm-api")))]
 use crate::primitives::UpwardMessage;
+#[cfg(any(feature = "std", all(not(feature = "std"), feature = "wasm-api")))]
 use sp_runtime_interface::runtime_interface;
 #[cfg(feature = "std")]
 use sp_externalities::ExternalitiesExt;
@@ -41,7 +43,9 @@ pub trait Parachain {
 /// Offset and length must have been provided by the validation
 /// function's entry point.
 #[cfg(not(feature = "std"))]
-pub unsafe fn load_params(params: *const u8, len: usize) -> crate::ValidationParams {
+pub unsafe fn load_params(params: *const u8, len: usize)
+	-> crate::primitives::ValidationParams
+{
 	let mut slice = rstd::slice::from_raw_parts(params, len);
 
 	codec::Decode::decode(&mut slice).expect("Invalid input data")
@@ -52,6 +56,6 @@ pub unsafe fn load_params(params: *const u8, len: usize) -> crate::ValidationPar
 /// As described in the crate docs, this is a pointer to the appended length
 /// of the vector.
 #[cfg(not(feature = "std"))]
-pub fn write_result(result: &crate::ValidationResult) -> u64 {
+pub fn write_result(result: &crate::primitives::ValidationResult) -> u64 {
 	sp_core::to_substrate_wasm_fn_return_value(&result)
 }

parachain/tests/adder/mod.rs

@@ -18,7 +18,15 @@
 
 use polkadot_parachain as parachain;
 
-use crate::{DummyExt, parachain::ValidationParams};
+use crate::{
+	DummyExt,
+	parachain::primitives::{
+		RelayChainBlockNumber,
+		BlockData as GenericBlockData,
+		HeadData as GenericHeadData,
+		ValidationParams,
+	},
+};
 use codec::{Decode, Encode};
 
 /// Head data for this parachain.
@@ -41,12 +49,6 @@ struct BlockData {
 	add: u64,
 }
 
-#[derive(Encode, Decode)]
-struct AddMessage {
-	/// amount to add.
-	amount: u64,
-}
-
 const TEST_CODE: &[u8] = adder::WASM_BINARY;
 
 fn hash_state(state: u64) -> [u8; 32] {
@@ -73,14 +75,18 @@ pub fn execute_good_on_parent() {
 	let ret = parachain::wasm_executor::validate_candidate(
 		TEST_CODE,
 		ValidationParams {
-			parent_head: parent_head.encode(),
-			block_data: block_data.encode(),
+			parent_head: GenericHeadData(parent_head.encode()),
+			block_data: GenericBlockData(block_data.encode()),
+			max_code_size: 1024,
+			max_head_data_size: 1024,
+			relay_chain_height: 1,
+			code_upgrade_allowed: None,
 		},
 		DummyExt,
 		parachain::wasm_executor::ExecutionMode::RemoteTest,
 	).unwrap();
 
-	let new_head = HeadData::decode(&mut &ret.head_data[..]).unwrap();
+	let new_head = HeadData::decode(&mut &ret.head_data.0[..]).unwrap();
 
 	assert_eq!(new_head.number, 1);
 	assert_eq!(new_head.parent_hash, hash_head(&parent_head));
@@ -108,14 +114,18 @@ fn execute_good_chain_on_parent() {
 		let ret = parachain::wasm_executor::validate_candidate(
 			TEST_CODE,
 			ValidationParams {
-				parent_head: parent_head.encode(),
-				block_data: block_data.encode(),
+				parent_head: GenericHeadData(parent_head.encode()),
+				block_data: GenericBlockData(block_data.encode()),
+				max_code_size: 1024,
+				max_head_data_size: 1024,
+				relay_chain_height: number as RelayChainBlockNumber + 1,
+				code_upgrade_allowed: None,
 			},
 			DummyExt,
 			parachain::wasm_executor::ExecutionMode::RemoteTest,
 		).unwrap();
 
-		let new_head = HeadData::decode(&mut &ret.head_data[..]).unwrap();
+		let new_head = HeadData::decode(&mut &ret.head_data.0[..]).unwrap();
 
 		assert_eq!(new_head.number, number + 1);
 		assert_eq!(new_head.parent_hash, hash_head(&parent_head));
@@ -143,8 +153,12 @@ fn execute_bad_on_parent() {
 	let _ret = parachain::wasm_executor::validate_candidate(
 		TEST_CODE,
 		ValidationParams {
-			parent_head: parent_head.encode(),
-			block_data: block_data.encode(),
+			parent_head: GenericHeadData(parent_head.encode()),
+			block_data: GenericBlockData(block_data.encode()),
+			max_code_size: 1024,
+			max_head_data_size: 1024,
+			relay_chain_height: 1,
+			code_upgrade_allowed: None,
 		},
 		DummyExt,
 		parachain::wasm_executor::ExecutionMode::RemoteTest,

parachain/tests/lib.rs

@@ -19,7 +19,7 @@ mod wasm_executor;
 
 use polkadot_parachain as parachain;
 use crate::parachain::{
-	UpwardMessage, wasm_executor::{Externalities, run_worker},
+	primitives::UpwardMessage, wasm_executor::{Externalities, run_worker},
 };
 
 struct DummyExt;

parachain/tests/wasm_executor/mod.rs

@@ -18,7 +18,10 @@
 
 use polkadot_parachain as parachain;
 use crate::{adder, DummyExt};
-use crate::parachain::{ValidationParams, wasm_executor::EXECUTION_TIMEOUT_SEC};
+use crate::parachain::{
+	primitives::{BlockData, ValidationParams},
+	wasm_executor::EXECUTION_TIMEOUT_SEC,
+};
 
 // Code that exposes `validate_block` and loops infinitely
 const INFINITE_LOOP_CODE: &[u8] = halt::WASM_BINARY;
@@ -28,8 +31,12 @@ fn terminates_on_timeout() {
 	let result = parachain::wasm_executor::validate_candidate(
 		INFINITE_LOOP_CODE,
 		ValidationParams {
+			block_data: BlockData(Vec::new()),
 			parent_head: Default::default(),
-			block_data: Vec::new(),
+			max_code_size: 1024,
+			max_head_data_size: 1024,
+			relay_chain_height: 1,
+			code_upgrade_allowed: None,
 		},
 		DummyExt,
 		parachain::wasm_executor::ExecutionMode::RemoteTest,
@@ -50,17 +57,25 @@ fn parallel_execution() {
 		parachain::wasm_executor::validate_candidate(
 		INFINITE_LOOP_CODE,
 		ValidationParams {
+			block_data: BlockData(Vec::new()),
 			parent_head: Default::default(),
-			block_data: Vec::new(),
+			max_code_size: 1024,
+			max_head_data_size: 1024,
+			relay_chain_height: 1,
+			code_upgrade_allowed: None,
 		},
 		DummyExt,
 		parachain::wasm_executor::ExecutionMode::RemoteTest,
 	).ok());
 	let _ = parachain::wasm_executor::validate_candidate(
 		INFINITE_LOOP_CODE,
 		ValidationParams {
+			block_data: BlockData(Vec::new()),
 			parent_head: Default::default(),
-			block_data: Vec::new(),
+			max_code_size: 1024,
+			max_head_data_size: 1024,
+			relay_chain_height: 1,
+			code_upgrade_allowed: None,
 		},
 		DummyExt,
 		parachain::wasm_executor::ExecutionMode::RemoteTest,

test-parachains/adder/collator/src/main.rs

@@ -24,7 +24,7 @@ use sp_core::Pair;
 use codec::{Encode, Decode};
 use primitives::{
 	Hash,
-	parachain::{HeadData, BlockData, Id as ParaId, LocalValidationData},
+	parachain::{HeadData, BlockData, Id as ParaId, LocalValidationData, GlobalValidationSchedule},
 };
 use collator::{
 	InvalidHead, ParachainContext, Network, BuildParachainContext, load_spec, Configuration,
@@ -60,6 +60,7 @@ impl ParachainContext for AdderContext {
 	fn produce_candidate(
 		&mut self,
 		_relay_parent: Hash,
+		_global_validation: GlobalValidationSchedule,
 		local_validation: LocalValidationData,
 	) -> Self::ProduceCandidate
 	{
@@ -83,7 +84,7 @@ impl ParachainContext for AdderContext {
 			add: adder_head.number % 100,
 		};
 
-		let next_head = ::adder::execute(adder_head.hash(), adder_head, &next_body)
+		let next_head = adder::execute(adder_head.hash(), adder_head, &next_body)
 			.expect("good execution params; qed");
 
 		let encoded_head = HeadData(next_head.encode());

test-parachains/adder/src/lib.rs

@@ -63,27 +63,10 @@ pub fn hash_state(state: u64) -> [u8; 32] {
 	tiny_keccak::keccak256(state.encode().as_slice())
 }
 
-#[derive(Default, Encode, Decode)]
-pub struct AddMessage {
-	/// The amount to add based on this message.
-	pub amount: u64,
-}
-
 /// Start state mismatched with parent header's state hash.
 #[derive(Debug)]
 pub struct StateMismatch;
 
-/// Process all incoming messages, yielding the amount of addition from messages.
-///
-/// Ignores unknown message kinds.
-pub fn process_messages<I, T>(iterable: I) -> u64
-	where I: IntoIterator<Item=T>, T: AsRef<[u8]>
-{
-	iterable.into_iter()
-		.filter_map(|data| AddMessage::decode(&mut data.as_ref()).ok())
-		.fold(0u64, |a, c| a.overflowing_add(c.amount).0)
-}
-
 /// Execute a block body on top of given parent head, producing new parent head
 /// if valid.
 pub fn execute(

test-parachains/adder/src/wasm_validation.rs

@@ -18,7 +18,7 @@
 
 use crate::{HeadData, BlockData};
 use core::{intrinsics, panic};
-use parachain::ValidationResult;
+use parachain::primitives::{ValidationResult, HeadData as GenericHeadData};
 use codec::{Encode, Decode};
 
 #[panic_handler]
@@ -40,17 +40,20 @@ pub fn oom(_: core::alloc::Layout) -> ! {
 #[no_mangle]
 pub extern fn validate_block(params: *const u8, len: usize) -> u64 {
 	let params = unsafe { parachain::load_params(params, len) };
-	let parent_head = HeadData::decode(&mut &params.parent_head[..])
+	let parent_head = HeadData::decode(&mut &params.parent_head.0[..])
 		.expect("invalid parent head format.");
 
-	let block_data = BlockData::decode(&mut &params.block_data[..])
+	let block_data = BlockData::decode(&mut &params.block_data.0[..])
 		.expect("invalid block data format.");
 
-	let parent_hash = tiny_keccak::keccak256(&params.parent_head[..]);
+	let parent_hash = tiny_keccak::keccak256(&params.parent_head.0[..]);
 
 	match crate::execute(parent_hash, parent_head, &block_data) {
 		Ok(new_head) => parachain::write_result(
-			&ValidationResult { head_data: new_head.encode() }
+			&ValidationResult {
+				head_data: GenericHeadData(new_head.encode()),
+				new_validation_code: None,
+			}
 		),
 		Err(_) => panic!("execution failure"),
 	}