Introduce toy runtime for testing inside substrate. (#66)

* Introduce simple blockchain runtime for substrate tests.

* Remove bad files.

* Add needed wasm binaries.

* Refactoring.

- Repot files in test-runtime.
- Rename troublesome `Joiner::join` to `Joiner::and`.
- Rework `Slicable` to dedup code.

* More fixes and refactoring

* Rebuild substrate test wasm.

* Fix merge errors.

* Rename the disasterously named `to_vec` to `encode`.

Also rename `as_slice_then` to `with_encoded`.

* Tests for toy runtime.

* Fix doc nit

substrate/polkadot/primitives/src/block.rs

@@ -42,8 +42,8 @@ impl Slicable for Log {
 		Vec::<u8>::decode(input).map(Log)
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		self.0.as_slice_then(f)
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(f)
 	}
 }
 
@@ -62,8 +62,8 @@ impl Slicable for Digest {
 		Vec::<Log>::decode(input).map(|logs| Digest { logs })
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		self.logs.as_slice_then(f)
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.logs.using_encoded(f)
 	}
 }
 
@@ -86,18 +86,14 @@ impl Slicable for Block {
 		Some(Block { header, transactions })
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 
-		v.extend(self.header.to_vec());
-		v.extend(self.transactions.to_vec());
+		v.extend(self.header.encode());
+		v.extend(self.transactions.encode());
 
 		v
 	}
-
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(self.to_vec().as_slice())
-	}
 }
 
 /// A relay chain block header.
@@ -144,21 +140,17 @@ impl Slicable for Header {
 		})
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 
-		self.parent_hash.as_slice_then(|s| v.extend(s));
-		self.number.as_slice_then(|s| v.extend(s));
-		self.state_root.as_slice_then(|s| v.extend(s));
-		self.transaction_root.as_slice_then(|s| v.extend(s));
-		self.digest.as_slice_then(|s| v.extend(s));
+		self.parent_hash.using_encoded(|s| v.extend(s));
+		self.number.using_encoded(|s| v.extend(s));
+		self.state_root.using_encoded(|s| v.extend(s));
+		self.transaction_root.using_encoded(|s| v.extend(s));
+		self.digest.using_encoded(|s| v.extend(s));
 
 		v
 	}
-
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(self.to_vec().as_slice())
-	}
 }
 
 #[cfg(test)]
@@ -189,7 +181,7 @@ mod tests {
   }
 }"#);
 
-		let v = header.to_vec();
+		let v = header.encode();
 		assert_eq!(Header::decode(&mut &v[..]).unwrap(), header);
 	}
 }

substrate/polkadot/primitives/src/parachain.rs

@@ -40,8 +40,8 @@ impl Slicable for Id {
 		u32::decode(input).map(Id)
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		self.0.as_slice_then(f)
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(f)
 	}
 }
 
@@ -66,21 +66,21 @@ impl Slicable for Chain {
 		}
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 		match *self {
-			Chain::Relay => { 0u8.as_slice_then(|s| v.extend(s)); }
+			Chain::Relay => { 0u8.using_encoded(|s| v.extend(s)); }
 			Chain::Parachain(id) => {
-				1u8.as_slice_then(|s| v.extend(s));
-				id.as_slice_then(|s| v.extend(s));
+				1u8.using_encoded(|s| v.extend(s));
+				id.using_encoded(|s| v.extend(s));
 			}
 		}
 
 		v
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(&self.to_vec().as_slice())
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(&self.encode().as_slice())
 	}
 }
 
@@ -105,17 +105,17 @@ impl Slicable for DutyRoster {
 		})
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 
-		v.extend(self.validator_duty.to_vec());
-		v.extend(self.guarantor_duty.to_vec());
+		v.extend(self.validator_duty.encode());
+		v.extend(self.guarantor_duty.encode());
 
 		v
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(&self.to_vec().as_slice())
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(&self.encode().as_slice())
 	}
 }
 
@@ -204,8 +204,8 @@ impl Slicable for Activity {
 		Vec::<u8>::decode(input).map(Activity)
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		self.0.as_slice_then(f)
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(f)
 	}
 }
 

substrate/polkadot/primitives/src/transaction.rs

@@ -113,47 +113,43 @@ impl Slicable for Proposal {
 		Some(function)
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 		match *self {
 			Proposal::SystemSetCode(ref data) => {
-				(InternalFunctionId::SystemSetCode as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::SystemSetCode as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Proposal::SessionSetLength(ref data) => {
-				(InternalFunctionId::SessionSetLength as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::SessionSetLength as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Proposal::SessionForceNewSession => {
-				(InternalFunctionId::SessionForceNewSession as u8).as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::SessionForceNewSession as u8).using_encoded(|s| v.extend(s));
 			}
 			Proposal::StakingSetSessionsPerEra(ref data) => {
-				(InternalFunctionId::StakingSetSessionsPerEra as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::StakingSetSessionsPerEra as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Proposal::StakingSetBondingDuration(ref data) => {
-				(InternalFunctionId::StakingSetBondingDuration as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::StakingSetBondingDuration as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Proposal::StakingSetValidatorCount(ref data) => {
-				(InternalFunctionId::StakingSetValidatorCount as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::StakingSetValidatorCount as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Proposal::StakingForceNewEra => {
-				(InternalFunctionId::StakingForceNewEra as u8).as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::StakingForceNewEra as u8).using_encoded(|s| v.extend(s));
 			}
 			Proposal::GovernanceSetApprovalPpmRequired(ref data) => {
-				(InternalFunctionId::GovernanceSetApprovalPpmRequired as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(InternalFunctionId::GovernanceSetApprovalPpmRequired as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 		}
 
 		v
 	}
-
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(self.to_vec().as_slice())
-	}
 }
 
 
@@ -232,43 +228,43 @@ impl Slicable for Function {
 		})
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 		match *self {
 			Function::TimestampSet(ref data) => {
-				(FunctionId::TimestampSet as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(FunctionId::TimestampSet as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Function::SessionSetKey(ref data) => {
-				(FunctionId::SessionSetKey as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(FunctionId::SessionSetKey as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Function::StakingStake => {
-				(FunctionId::StakingStake as u8).as_slice_then(|s| v.extend(s));
+				(FunctionId::StakingStake as u8).using_encoded(|s| v.extend(s));
 			}
 			Function::StakingUnstake => {
-				(FunctionId::StakingUnstake as u8).as_slice_then(|s| v.extend(s));
+				(FunctionId::StakingUnstake as u8).using_encoded(|s| v.extend(s));
 			}
 			Function::StakingTransfer(ref to, ref amount) => {
-				(FunctionId::StakingTransfer as u8).as_slice_then(|s| v.extend(s));
-				to.as_slice_then(|s| v.extend(s));
-				amount.as_slice_then(|s| v.extend(s));
+				(FunctionId::StakingTransfer as u8).using_encoded(|s| v.extend(s));
+				to.using_encoded(|s| v.extend(s));
+				amount.using_encoded(|s| v.extend(s));
 			}
 			Function::GovernancePropose(ref data) => {
-				(FunctionId::GovernancePropose as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(FunctionId::GovernancePropose as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 			Function::GovernanceApprove(ref data) => {
-				(FunctionId::GovernanceApprove as u8).as_slice_then(|s| v.extend(s));
-				data.as_slice_then(|s| v.extend(s));
+				(FunctionId::GovernanceApprove as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
 			}
 		}
 
 		v
 	}
 
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(self.to_vec().as_slice())
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.encode().as_slice())
 	}
 }
 
@@ -293,19 +289,15 @@ impl Slicable for Transaction {
 		})
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 
-		self.signed.as_slice_then(|s| v.extend(s));
-		self.nonce.as_slice_then(|s| v.extend(s));
-		self.function.as_slice_then(|s| v.extend(s));
+		self.signed.using_encoded(|s| v.extend(s));
+		self.nonce.using_encoded(|s| v.extend(s));
+		self.function.using_encoded(|s| v.extend(s));
 
 		v
 	}
-
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(self.to_vec().as_slice())
-	}
 }
 
 impl ::codec::NonTrivialSlicable for Transaction {}
@@ -334,27 +326,23 @@ impl Slicable for UncheckedTransaction {
 		})
 	}
 
-	fn to_vec(&self) -> Vec<u8> {
+	fn encode(&self) -> Vec<u8> {
 		let mut v = Vec::new();
 
 		// need to prefix with the total length as u32 to ensure it's binary comptible with
 		// Vec<u8>. we'll make room for it here, then overwrite once we know the length.
 		v.extend(&[0u8; 4]);
 
-		self.transaction.signed.as_slice_then(|s| v.extend(s));
-		self.transaction.nonce.as_slice_then(|s| v.extend(s));
-		self.transaction.function.as_slice_then(|s| v.extend(s));
-		self.signature.as_slice_then(|s| v.extend(s));
+		self.transaction.signed.using_encoded(|s| v.extend(s));
+		self.transaction.nonce.using_encoded(|s| v.extend(s));
+		self.transaction.function.using_encoded(|s| v.extend(s));
+		self.signature.using_encoded(|s| v.extend(s));
 
 		let length = (v.len() - 4) as u32;
-		length.as_slice_then(|s| v[0..4].copy_from_slice(s));
+		length.using_encoded(|s| v[0..4].copy_from_slice(s));
 
 		v
 	}
-
-	fn as_slice_then<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-		f(self.to_vec().as_slice())
-	}
 }
 
 impl ::codec::NonTrivialSlicable for UncheckedTransaction {}
@@ -396,7 +384,7 @@ mod tests {
 		// df0f0200
 		// 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 
-		let v = Slicable::to_vec(&tx);
+		let v = Slicable::encode(&tx);
 		println!("{}", HexDisplay::from(&v));
 		assert_eq!(UncheckedTransaction::decode(&mut &v[..]).unwrap(), tx);
 	}