Checked Tip + other fixes.

core/sr-primitives/src/generic/checked_extrinsic.rs

@@ -19,25 +19,29 @@
 
 use crate::traits::{self, Member, SimpleArithmetic, MaybeDisplay};
 use crate::weights::{Weighable, Weight};
+use crate::generic::tip::{Tip, Tippable};
 
 /// Definition of something that the external world might want to say; its
 /// existence implies that it has been checked and is good, particularly with
 /// regards to the signature.
 #[derive(PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "std", derive(Debug))]
-pub struct CheckedExtrinsic<AccountId, Index, Call> {
+pub struct CheckedExtrinsic<AccountId, Index, Call, Balance> {
 	/// Who this purports to be from and the number of extrinsics have come before
 	/// from the same signer, if anyone (note this is not a signature).
 	pub signed: Option<(AccountId, Index)>,
 	/// The function that should be called.
 	pub function: Call,
+	/// The validated tip value for this transaction.
+	pub tip: Tip<Balance>,
 }
 
-impl<AccountId, Index, Call> traits::Applyable for CheckedExtrinsic<AccountId, Index, Call>
+impl<AccountId, Index, Call, Balance> traits::Applyable for CheckedExtrinsic<AccountId, Index, Call, Balance>
 where
 	AccountId: Member + MaybeDisplay,
 	Index: Member + MaybeDisplay + SimpleArithmetic,
 	Call: Member,
+	Balance: Member,
 {
 	type Index = Index;
 	type AccountId = AccountId;
@@ -56,11 +60,21 @@ where
 	}
 }
 
-impl<AccountId, Index, Call> Weighable for CheckedExtrinsic<AccountId, Index, Call>
+impl<AccountId, Index, Call, Balance> Weighable for CheckedExtrinsic<AccountId, Index, Call, Balance>
 where
 	Call: Weighable,
 {
 	fn weight(&self, len: usize) -> Weight {
 		self.function.weight(len)
 	}
 }
+
+impl<AccountId, Index, Call, Balance> Tippable<Balance>
+	for CheckedExtrinsic<AccountId, Index, Call, Balance>
+where
+	Balance: Clone,
+{
+	fn tip(&self) -> Tip<Balance> {
+		self.tip.clone()
+	}
+}

core/sr-primitives/src/generic/unchecked_extrinsic.rs

@@ -21,7 +21,7 @@ use std::fmt;
 use rstd::prelude::*;
 use crate::codec::{Decode, Encode, Codec, Input, HasCompact};
 use crate::traits::{self, Member, SimpleArithmetic, MaybeDisplay, Lookup, Extrinsic};
-use super::{CheckedExtrinsic, Tip, Tippable};
+use super::{CheckedExtrinsic, Tip};
 
 #[derive(PartialEq, Eq, Clone, Encode, Decode)]
 pub struct SignatureContent<Address, Index, Signature>
@@ -74,11 +74,11 @@ where
 	}
 
 	/// New instance of an unsigned extrinsic aka "inherent".
-	pub fn new_unsigned(function: Call, tip: Tip<Balance>) -> Self {
+	pub fn new_unsigned(function: Call) -> Self {
 		UncheckedExtrinsic {
 			signature: None,
 			function,
-			tip,
+			tip: Tip::None,
 		}
 	}
 }
@@ -92,43 +92,35 @@ where
 	Signature: Member + traits::Verify<Signer=AccountId> + Codec,
 	AccountId: Member + MaybeDisplay,
 	Context: Lookup<Source=Address, Target=AccountId>,
+	Balance: Member + Encode,
 {
-	type Checked = CheckedExtrinsic<AccountId, Index, Call>;
+	type Checked = CheckedExtrinsic<AccountId, Index, Call, Balance>;
 
 	fn check(self, context: &Context) -> Result<Self::Checked, &'static str> {
 		Ok(match self.signature {
 			Some(SignatureContent{signed, signature, index}) => {
-				let payload = (index, self.function);
+				let payload = (index, self.function, self.tip);
 				let signed = context.lookup(signed)?;
 				if !crate::verify_encoded_lazy(&signature, &payload, &signed) {
 					return Err(crate::BAD_SIGNATURE)
 				}
+				// TODO: maybe add tip to checked as well? hmm..
 				CheckedExtrinsic {
 					signed: Some((signed, payload.0)),
 					function: payload.1,
+					tip: payload.2,
 				}
 			}
 			None => CheckedExtrinsic {
 				signed: None,
 				function: self.function,
+				// an unsigned transaction cannot have tips.
+				tip: Tip::None,
 			},
 		})
 	}
 }
 
-impl<Address, Index, Signature, Call, Balance> Tippable<Balance>
-	for UncheckedExtrinsic<Address, Index, Call, Signature, Balance>
-where
-	Index: HasCompact + Codec,
-	Signature: Codec,
-	Address: Codec,
-	Balance: Clone,
-{
-	fn tip(&self) -> Tip<Balance> {
-		self.tip.clone()
-	}
-}
-
 impl<
 	Address: Codec,
 	Index: HasCompact + Codec,
@@ -216,39 +208,25 @@ where
 #[cfg(test)]
 mod test {
 	use crate::codec::{Decode, Encode};
-	use super::{UncheckedExtrinsic, Tip};
+	use super::{UncheckedExtrinsic};
 	type Extrinsic = UncheckedExtrinsic<u32, u32, u32, u32, u32>;
 
 
 	#[test]
 	fn encoding_matches_vec() {
-		let ex = Extrinsic::new_unsigned(42, Tip::Sender(10_u32));
+		let ex = Extrinsic::new_unsigned(42);
 		let encoded = ex.encode();
 		let decoded = Extrinsic::decode(&mut encoded.as_slice()).unwrap();
 		assert_eq!(decoded, ex);
 		let as_vec: Vec<u8> = Decode::decode(&mut encoded.as_slice()).unwrap();
 		assert_eq!(as_vec.encode(), encoded);
 	}
 
-	#[test]
-	fn unprovided_tip_will_not_fail() {
-		// without tip
-		//                       len sig f(u32).....
-		let bytes: Vec<u8> = vec![24, 0, 42, 0, 0, 0];
-		let decoded: Extrinsic = Decode::decode(&mut bytes.as_slice()).unwrap();
-		assert_eq!(decoded, Extrinsic::new_unsigned(42, Tip::default()));
-		// with tip
-		let bytes: Vec<u8> = vec![40, 0, 42, 0, 0, 0, 1, 10, 0, 0, 0];
-		let decoded: Extrinsic = Decode::decode(&mut bytes.as_slice()).unwrap();
-		assert_eq!(decoded, Extrinsic::new_unsigned(42, Tip::Sender(10)));
-
-	}
-
 	#[test]
 	#[cfg(feature = "std")]
 	fn serialization_of_unchecked_extrinsics() {
 		type Extrinsic = UncheckedExtrinsic<u32, u32, u32, u32, u32>;
-		let ex = Extrinsic::new_unsigned(42, Tip::None);
+		let ex = Extrinsic::new_unsigned(42);
 		assert_eq!(serde_json::to_string(&ex).unwrap(), "\"0x18002a00000000\"");
 	}
 }