ICMP message-routing gossip

availability-store/src/lib.rs

@@ -42,6 +42,16 @@ pub struct Config {
 	pub path: PathBuf,
 }
 
+/// A record containing information about parachain extrinsic data to store.
+pub struct StoredExtrinsic {
+	/// The actual extrinsic data.
+	pub inner: Extrinsic,
+	/// The queue root of the `outgoing_messages` member of `inner`.
+	///
+	/// The responsibility is on the creator to set this correctly.
+	pub message_queue_root: Hash,
+}
+
 /// Some data to keep available.
 pub struct Data {
 	/// The relay chain parent hash this should be localized to.
@@ -53,7 +63,7 @@ pub struct Data {
 	/// Block data.
 	pub block_data: BlockData,
 	/// Extrinsic data.
-	pub extrinsic: Option<Extrinsic>,
+	pub extrinsic: Option<StoredExtrinsic>,
 }
 
 fn block_data_key(relay_parent: &Hash, candidate_hash: &Hash) -> Vec<u8> {
@@ -119,10 +129,17 @@ impl Store {
 		);
 
 		if let Some(extrinsic) = data.extrinsic {
+			let encoded = extrinsic.inner.encode();
 			tx.put_vec(
 				columns::DATA,
 				extrinsic_key(&data.relay_parent, &data.candidate_hash).as_slice(),
-				extrinsic.encode(),
+				encoded.clone(),
+			);
+
+			tx.put_vec(
+				columns::DATA,
+				extrinsic.message_queue_root.as_ref(),
+				encoded,
 			);
 		}
 
@@ -168,10 +185,8 @@ impl Store {
 		}
 	}
 
-	/// Query extrinsic data.
-	pub fn extrinsic(&self, relay_parent: Hash, candidate_hash: Hash) -> Option<Extrinsic> {
-		let encoded_key = extrinsic_key(&relay_parent, &candidate_hash);
-		match self.inner.get(columns::DATA, &encoded_key[..]) {
+	fn extrinsic_with_key(&self, key: &[u8]) -> Option<Extrinsic> {
+		match self.inner.get(columns::DATA, key) {
 			Ok(Some(raw)) => Some(
 				Extrinsic::decode(&mut &raw[..]).expect("all stored data serialized correctly; qed")
 			),
@@ -182,11 +197,23 @@ impl Store {
 			}
 		}
 	}
+
+	/// Query extrinsic data by relay parent and candidate hash.
+	pub fn extrinsic(&self, relay_parent: Hash, candidate_hash: Hash) -> Option<Extrinsic> {
+		let encoded_key = extrinsic_key(&relay_parent, &candidate_hash);
+		self.extrinsic_with_key(&encoded_key[..])
+	}
+
+	/// Query extrinsic data by message queue root hash.
+	pub fn extrinsic_by_queue_root(&self, queue_root: &Hash) -> Option<Extrinsic> {
+		self.extrinsic_with_key(queue_root.as_ref())
+	}
 }
 
 #[cfg(test)]
 mod tests {
 	use super::*;
+	use polkadot_primitives::parachain::OutgoingMessage;
 
 	#[test]
 	fn finalization_removes_unneeded() {
@@ -207,15 +234,21 @@ mod tests {
 			parachain_id: para_id_1,
 			candidate_hash: candidate_1,
 			block_data: block_data_1.clone(),
-			extrinsic: Some(Extrinsic { outgoing_messages: Vec::new() }),
+			extrinsic: Some(StoredExtrinsic {
+				inner: Extrinsic { outgoing_messages: Vec::new() },
+				message_queue_root: Default::default(),
+			}),
 		}).unwrap();
 
 		store.make_available(Data {
 			relay_parent,
 			parachain_id: para_id_2,
 			candidate_hash: candidate_2,
 			block_data: block_data_2.clone(),
-			extrinsic: Some(Extrinsic { outgoing_messages: Vec::new() }),
+			extrinsic: Some(StoredExtrinsic {
+				inner: Extrinsic { outgoing_messages: Vec::new() },
+				message_queue_root: Default::default(),
+			}),
 		}).unwrap();
 
 		assert_eq!(store.block_data(relay_parent, candidate_1).unwrap(), block_data_1);
@@ -232,4 +265,34 @@ mod tests {
 		assert!(store.extrinsic(relay_parent, candidate_1).is_some());
 		assert!(store.extrinsic(relay_parent, candidate_2).is_none());
 	}
+
+	#[test]
+	fn extrinsic_available_by_queue_root() {
+		let relay_parent = [1; 32].into();
+		let para_id = 5.into();
+		let candidate = [2; 32].into();
+		let block_data = BlockData(vec![1, 2, 3]);
+
+		let outgoing_messages = vec![
+			OutgoingMessage { target: 1.into(), data: vec![1, 2, 3, 4] },
+			OutgoingMessage { target: 2.into(), data: vec![5, 6, 7, 8] },
+		];
+		let ex = Extrinsic { outgoing_messages };
+
+		let message_queue_root = [0x42; 32].into();
+
+		let store = Store::new_in_memory();
+		store.make_available(Data {
+			relay_parent,
+			parachain_id: para_id,
+			candidate_hash: candidate,
+			block_data: block_data.clone(),
+			extrinsic: Some(StoredExtrinsic {
+				inner: ex.clone(),
+				message_queue_root,
+			}),
+		}).unwrap();
+
+		assert_eq!(store.extrinsic_by_queue_root(&message_queue_root), Some(ex));
+	}
 }

collator/src/lib.rs

@@ -66,7 +66,7 @@ use polkadot_cli::{
 	ParachainHost,
 };
 use polkadot_network::validation::{SessionParams, ValidationNetwork};
-use polkadot_network::NetworkService;
+use polkadot_network::PolkadotNetworkService;
 use tokio::timer::Timeout;
 use consensus_common::SelectChain;
 
@@ -92,7 +92,7 @@ pub trait Network: Send + Sync {
 	fn checked_statements(&self, relay_parent: Hash) -> Box<dyn Stream<Item=SignedStatement, Error=()>>;
 }
 
-impl<P, E> Network for ValidationNetwork<P, E, NetworkService, TaskExecutor> where
+impl<P, E> Network for ValidationNetwork<P, E, PolkadotNetworkService, TaskExecutor> where
 	P: 'static + Send + Sync,
 	E: 'static + Send + Sync,
 {
@@ -227,7 +227,7 @@ pub fn collate<'a, R, P>(
 
 /// Polkadot-api context.
 struct ApiContext<P, E> {
-	network: Arc<ValidationNetwork<P, E, NetworkService, TaskExecutor>>,
+	network: Arc<ValidationNetwork<P, E, PolkadotNetworkService, TaskExecutor>>,
 	parent_hash: Hash,
 	validators: Vec<ValidatorId>,
 }
@@ -301,26 +301,28 @@ impl<P, E> Worker for CollationNode<P, E> where
 			return Box::new(future::err(()));
 		};
 
+		let is_known = move |block_hash: &Hash| {
+			use client::BlockStatus;
+			use polkadot_network::gossip::Known;
+
+			match known_oracle.block_status(&BlockId::hash(*block_hash)) {
+				Err(_) | Ok(BlockStatus::Unknown) | Ok(BlockStatus::Queued) => None,
+				Ok(BlockStatus::KnownBad) => Some(Known::Bad),
+				Ok(BlockStatus::InChainWithState) | Ok(BlockStatus::InChainPruned) =>
+					match select_chain.leaves() {
+						Err(_) => None,
+						Ok(leaves) => if leaves.contains(block_hash) {
+							Some(Known::Leaf)
+						} else {
+							Some(Known::Old)
+						},
+					}
+			}
+		};
+
 		let message_validator = polkadot_network::gossip::register_validator(
 			network.clone(),
-			move |block_hash: &Hash| {
-				use client::BlockStatus;
-				use polkadot_network::gossip::Known;
-
-				match known_oracle.block_status(&BlockId::hash(*block_hash)) {
-					Err(_) | Ok(BlockStatus::Unknown) | Ok(BlockStatus::Queued) => None,
-					Ok(BlockStatus::KnownBad) => Some(Known::Bad),
-					Ok(BlockStatus::InChainWithState) | Ok(BlockStatus::InChainPruned) =>
-						match select_chain.leaves() {
-							Err(_) => None,
-							Ok(leaves) => if leaves.contains(block_hash) {
-								Some(Known::Leaf)
-							} else {
-								Some(Known::Old)
-							},
-						}
-				}
-			},
+			(is_known, client.clone()),
 		);
 
 		let validation_network = Arc::new(ValidationNetwork::new(

network/Cargo.toml

@@ -18,7 +18,7 @@ sr-primitives = { git = "https://github.com/paritytech/substrate", branch = "pol
 futures = "0.1"
 log = "0.4"
 exit-future = "0.1.4"
+substrate-client = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 
 [dev-dependencies]
-substrate-client = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }
 substrate-keyring = { git = "https://github.com/paritytech/substrate", branch = "polkadot-master" }