Submit (& sign) extrinsics from the runtime.

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

@@ -27,7 +27,7 @@ mod digest;
 #[cfg(test)]
 mod tests;
 
-pub use self::unchecked_extrinsic::UncheckedExtrinsic;
+pub use self::unchecked_extrinsic::{UncheckedExtrinsic, SignedPayload};
 pub use self::era::{Era, Phase};
 pub use self::checked_extrinsic::CheckedExtrinsic;
 pub use self::header::Header;

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

@@ -72,12 +72,22 @@ impl<Address, Call, Signature, Extra: SignedExtension> Extrinsic
 {
 	type Call = Call;
 
+	type SignaturePayload = (
+		Address,
+		Signature,
+		Extra,
+	);
+
 	fn is_signed(&self) -> Option<bool> {
 		Some(self.signature.is_some())
 	}
 
-	fn new_unsigned(function: Call) -> Option<Self> {
-		Some(UncheckedExtrinsic::new_unsigned(function))
+	fn new(function: Call, signed_data: Option<Self::SignaturePayload>) -> Option<Self> {
+		Some(if let Some((address, signature, extra)) = signed_data {
+			UncheckedExtrinsic::new_signed(function, address, signature, extra)
+		} else {
+			UncheckedExtrinsic::new_unsigned(function)
+		})
 	}
 }
 
@@ -98,21 +108,18 @@ where
 	fn check(self, lookup: &Lookup) -> Result<Self::Checked, &'static str> {
 		Ok(match self.signature {
 			Some((signed, signature, extra)) => {
-				let additional_signed = extra.additional_signed()?;
-				let raw_payload = (self.function, extra, additional_signed);
 				let signed = lookup.lookup(signed)?;
+				let raw_payload = SignedPayload::new(self.function, extra)?;
 				if !raw_payload.using_encoded(|payload| {
-					if payload.len() > 256 {
-						signature.verify(&blake2_256(payload)[..], &signed)
-					} else {
-						signature.verify(payload, &signed)
-					}
+					signature.verify(payload, &signed)
 				}) {
 					return Err(crate::BAD_SIGNATURE)
 				}
+
+				let (function, extra, _) = raw_payload.deconstruct();
 				CheckedExtrinsic {
-					signed: Some((signed, raw_payload.1)),
-					function: raw_payload.0,
+					signed: Some((signed, extra)),
+					function,
 				}
 			}
 			None => CheckedExtrinsic {
@@ -123,6 +130,59 @@ where
 	}
 }
 
+/// A payload that has been signed for an unchecked extrinsics.
+///
+/// Note that the payload that we sign to produce unchecked extrinsic signature
+/// is going to be different than the `SignaturePayload` - so the thing the extrinsic
+/// actually contains.
+pub struct SignedPayload<Call, Extra: SignedExtension>((
+		Call,
+		Extra,
+		Extra::AdditionalSigned,
+));
+
+impl<Call, Extra> SignedPayload<Call, Extra> where
+	Call: Encode,
+	Extra: SignedExtension,
+{
+	/// Create new `SignedPayload`.
+	///
+	/// This function may fail if `additional_signed` of `Extra` is not available.
+	pub fn new(call: Call, extra: Extra) -> Result<Self, &'static str> {
+		let additional_signed = extra.additional_signed()?;
+		let raw_payload = (call, extra, additional_signed);
+		Ok(Self(raw_payload))
+	}
+
+	/// Create new `SignedPayload` from raw components.
+	pub fn from_raw(call: Call, extra: Extra, additional_signed: Extra::AdditionalSigned) -> Self {
+		Self((call, extra, additional_signed))
+	}
+
+	/// Deconstruct the payload into it's components.
+	pub fn deconstruct(self) -> (Call, Extra, Extra::AdditionalSigned) {
+		self.0
+	}
+}
+
+impl<Call, Extra> Encode for SignedPayload<Call, Extra> where
+	Call: Encode,
+	Extra: SignedExtension,
+{
+	/// Get an encoded version of this payload.
+	///
+	/// Payloads longer than 256 bytes are going to be `blake2_256`-hashed.
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(|payload| {
+			if payload.len() > 256 {
+				f(&blake2_256(payload)[..])
+			} else {
+				f(payload)
+			}
+		})
+	}
+}
+
 impl<Address, Call, Signature, Extra> Decode
 	for UncheckedExtrinsic<Address, Call, Signature, Extra>
 where

core/sr-primitives/src/lib.rs

@@ -847,12 +847,7 @@ impl<'a> ::serde::Deserialize<'a> for OpaqueExtrinsic {
 
 impl traits::Extrinsic for OpaqueExtrinsic {
 	type Call = ();
-
-	fn is_signed(&self) -> Option<bool> {
-		None
-	}
-
-	fn new_unsigned(_call: Self::Call) -> Option<Self> { None }
+	type SignaturePayload = ();
 }
 
 #[cfg(test)]

core/sr-primitives/src/testing.rs

@@ -187,6 +187,7 @@ pub struct ExtrinsicWrapper<Xt>(Xt);
 
 impl<Xt> traits::Extrinsic for ExtrinsicWrapper<Xt> {
 	type Call = ();
+	type SignaturePayload = ();
 
 	fn is_signed(&self) -> Option<bool> {
 		None
@@ -274,13 +275,14 @@ impl<Call: Codec + Sync + Send, Context, Extra> Checkable<Context> for TestXt<Ca
 }
 impl<Call: Codec + Sync + Send, Extra> traits::Extrinsic for TestXt<Call, Extra> {
 	type Call = Call;
+	type SignaturePayload = (u64, Extra);
 
 	fn is_signed(&self) -> Option<bool> {
 		Some(self.0.is_some())
 	}
 
-	fn new_unsigned(_c: Call) -> Option<Self> {
-		None
+	fn new(c: Call, sig: Option<Self::SignaturePayload>) -> Option<Self> {
+		Some(TestXt(sig, c))
 	}
 }
 

core/sr-primitives/src/traits.rs

@@ -743,13 +743,24 @@ pub trait Extrinsic: Sized {
 	/// The function call.
 	type Call;
 
+	/// The payload we carry for signed extrinsics.
+	///
+	/// Usually it will contain a `Signature` and
+	/// may include some additional data that are specific to signed
+	/// extrinsics.
+	type SignaturePayload;
+
 	/// Is this `Extrinsic` signed?
 	/// If no information are available about signed/unsigned, `None` should be returned.
 	fn is_signed(&self) -> Option<bool> { None }
 
-	/// New instance of an unsigned extrinsic aka "inherent". `None` if this is an opaque
-	/// extrinsic type.
-	fn new_unsigned(_call: Self::Call) -> Option<Self> { None }
+	/// Create new instance of the extrinsic.
+	///
+	/// Extrinsics can be split into:
+	/// 1. Inherents (no signature; created by validators during block production)
+	/// 2. Unsigned Transactions (no signature; represent "system calls" or other special kinds of calls)
+	/// 3. Signed Transactions (with signature; a regular transactions with known origin)
+	fn new(_call: Self::Call, _signed_data: Option<Self::SignaturePayload>) -> Option<Self> { None }
 }
 
 /// Extract the hashing type for a block.

core/test-runtime/src/lib.rs

@@ -141,6 +141,7 @@ impl BlindCheckable for Extrinsic {
 
 impl ExtrinsicT for Extrinsic {
 	type Call = Extrinsic;
+	type SignaturePayload = ();
 
 	fn is_signed(&self) -> Option<bool> {
 		if let Extrinsic::IncludeData(_) = *self {
@@ -150,7 +151,7 @@ impl ExtrinsicT for Extrinsic {
 		}
 	}
 
-	fn new_unsigned(call: Self::Call) -> Option<Self> {
+	fn new(call: Self::Call, _signature_payload: Option<Self::SignaturePayload>) -> Option<Self> {
 		Some(call)
 	}
 }

node/cli/src/service.rs

@@ -289,7 +289,7 @@ mod tests {
 		crypto::Pair as CryptoPair, blake2_256,
 		sr25519::Public as AddressPublic, H256,
 	};
-	use sr_primitives::{generic::{BlockId, Era, Digest}, traits::Block, OpaqueExtrinsic};
+	use sr_primitives::{generic::{BlockId, Era, Digest, SignedPayload}, traits::Block, OpaqueExtrinsic};
 	use timestamp;
 	use finality_tracker;
 	use keyring::AccountKeyring;
@@ -462,15 +462,17 @@ mod tests {
 				let check_weight = system::CheckWeight::new();
 				let take_fees = balances::TakeFees::from(0);
 				let extra = (check_version, check_genesis, check_era, check_nonce, check_weight, take_fees);
-
-				let raw_payload = (function, extra.clone(), version, genesis_hash, genesis_hash);
-				let signature = raw_payload.using_encoded(|payload| if payload.len() > 256 {
-					signer.sign(&blake2_256(payload)[..])
-				} else {
+				let raw_payload = SignedPayload::from_raw(
+					function,
+					extra,
+					(version, genesis_hash, genesis_hash, (), (), ())
+				);
+				let signature = raw_payload.using_encoded(|payload|	{
 					signer.sign(payload)
 				});
+				let (function, extra, _) = raw_payload.deconstruct();
 				let xt = UncheckedExtrinsic::new_signed(
-					raw_payload.0,
+					function,
 					from.into(),
 					signature.into(),
 					extra,

node/runtime/src/lib.rs

@@ -39,7 +39,7 @@ use sr_primitives::{ApplyResult, impl_opaque_keys, generic, create_runtime_str,
 use sr_primitives::transaction_validity::TransactionValidity;
 use sr_primitives::weights::Weight;
 use sr_primitives::traits::{
-	BlakeTwo256, Block as BlockT, DigestFor, NumberFor, StaticLookup,
+	self, BlakeTwo256, Block as BlockT, DigestFor, NumberFor, StaticLookup, SaturatedConversion,
 };
 use version::RuntimeVersion;
 use elections::VoteIndex;
@@ -48,6 +48,7 @@ use version::NativeVersion;
 use primitives::OpaqueMetadata;
 use grandpa::{AuthorityId as GrandpaId, AuthorityWeight as GrandpaWeight};
 use im_online::sr25519::{AuthorityId as ImOnlineId};
+use system::offchain::TransactionSubmitter;
 
 #[cfg(any(feature = "std", test))]
 pub use sr_primitives::BuildStorage;
@@ -80,7 +81,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
 	spec_version: 154,
-	impl_version: 157,
+	impl_version: 158,
 	apis: RUNTIME_API_VERSIONS,
 };
 
@@ -392,11 +393,13 @@ impl sudo::Trait for Runtime {
 	type Proposal = Call;
 }
 
+type SubmitTransaction = TransactionSubmitter<ImOnlineId, Runtime, UncheckedExtrinsic>;
+
 impl im_online::Trait for Runtime {
 	type AuthorityId = ImOnlineId;
 	type Call = Call;
 	type Event = Event;
-	type UncheckedExtrinsic = UncheckedExtrinsic;
+	type SubmitTransaction = SubmitTransaction;
 	type ReportUnresponsiveness = Offences;
 	type CurrentElectedSet = staking::CurrentElectedStashAccounts<Runtime>;
 }
@@ -424,6 +427,33 @@ impl finality_tracker::Trait for Runtime {
 	type ReportLatency = ReportLatency;
 }
 
+impl system::offchain::CreateTransaction<Runtime, UncheckedExtrinsic> for Runtime {
+	type Signature = Signature;
+
+	fn create_transaction<F: system::offchain::Signer<AccountId, Self::Signature>>(
+		call: Call,
+		account: AccountId,
+		index: Index,
+	) -> Option<(Call, <UncheckedExtrinsic as traits::Extrinsic>::SignaturePayload)> {
+		let period = 1 << 8;
+		let current_block = System::block_number().saturated_into::<u64>();
+		let tip = 0;
+		let extra: SignedExtra = (
+			system::CheckVersion::<Runtime>::new(),
+			system::CheckGenesis::<Runtime>::new(),
+			system::CheckEra::<Runtime>::from(generic::Era::mortal(period, current_block)),
+			system::CheckNonce::<Runtime>::from(index),
+			system::CheckWeight::<Runtime>::new(),
+			balances::TakeFees::<Runtime>::from(tip),
+		);
+		let raw_payload = SignedPayload::new(call, extra).ok()?;
+		let signature = F::sign(account.clone(), &raw_payload)?;
+		let address = Indices::unlookup(account);
+		let (call, extra, _) = raw_payload.deconstruct();
+		Some((call, (address, signature, extra)))
+	}
+}
+
 construct_runtime!(
 	pub enum Runtime where
 		Block = Block,
@@ -475,6 +505,8 @@ pub type SignedExtra = (
 );
 /// Unchecked extrinsic type as expected by this runtime.
 pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
+/// The payload being signed in transactions.
+pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
 /// Extrinsic type that has already been checked.
 pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;
 /// Executive: handles dispatch to the various modules.
@@ -609,3 +641,28 @@ impl_runtime_apis! {
 		}
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sr_primitives::app_crypto::RuntimeAppPublic;
+	use system::offchain::SubmitSignedTransaction;
+
+	fn is_submit_signed_transaction<T, Signer>(_arg: T) where
+		T: SubmitSignedTransaction<
+			Runtime,
+			Call,
+			Extrinsic=UncheckedExtrinsic,
+			CreateTransaction=Runtime,
+			Signer=Signer,
+		>,
+		Signer: RuntimeAppPublic + From<AccountId>,
+		Signer::Signature: Into<Signature>,
+	{}
+
+	#[test]
+	fn validate_bounds() {
+		let x = SubmitTransaction::default();
+		is_submit_signed_transaction(x);
+	}
+}

srml/authority-discovery/src/lib.rs

@@ -194,7 +194,11 @@ mod tests {
 		type AuthorityId = AuthorityId;
 		type Call = im_online::Call<Test>;
 		type Event = ();
-		type UncheckedExtrinsic = UncheckedExtrinsic<(), im_online::Call<Test>, (), ()>;
+		type SubmitTransaction = system::offchain::TransactionSubmitter<
+			(),
+			im_online::Call<Test>,
+			UncheckedExtrinsic<(), im_online::Call<Test>, (), ()>,
+		>;
 		type ReportUnresponsiveness = ();
 		type CurrentElectedSet = DummyCurrentElectedSet<AuthorityId>;
 	}

srml/balances/src/lib.rs

@@ -1187,7 +1187,6 @@ pub struct TakeFees<T: Trait<I>, I: Instance = DefaultInstance>(#[codec(compact)
 
 impl<T: Trait<I>, I: Instance> TakeFees<T, I> {
 	/// utility constructor. Used only in client/factory code.
-	#[cfg(feature = "std")]
 	pub fn from(fee: T::Balance) -> Self {
 		Self(fee)
 	}