Transaction eras (#758)

* Initial groundwork

* A mess.

* Integrate

* Fix tests

* Unit tests

* Tests for unchecked_extrisnic

* fix tab

* Improve binary format.

* fix tests

* Rename extrinsic-pool -> transaction-pool

Closes #770

* Implement unimplemented.

* typo

substrate/core/service/src/components.rs

@@ -26,7 +26,7 @@ use client::{self, Client};
 use error;
 use network::{self, OnDemand};
 use substrate_executor::{NativeExecutor, NativeExecutionDispatch};
-use extrinsic_pool::{self, Options as ExtrinsicPoolOptions, Pool as ExtrinsicPool};
+use transaction_pool::{self, Options as TransactionPoolOptions, Pool as TransactionPool};
 use runtime_primitives::{traits::Block as BlockT, traits::Header as HeaderT, BuildStorage};
 use config::Configuration;
 use primitives::{Blake2Hasher, RlpCodec, H256};
@@ -101,13 +101,13 @@ pub type ComponentClient<C> = Client<
 pub type ComponentBlock<C> = <<C as Components>::Factory as ServiceFactory>::Block;
 
 /// Extrinsic hash type for `Components`
-pub type ComponentExHash<C> = <<C as Components>::ExtrinsicPoolApi as extrinsic_pool::ChainApi>::Hash;
+pub type ComponentExHash<C> = <<C as Components>::TransactionPoolApi as transaction_pool::ChainApi>::Hash;
 
 /// Extrinsic type.
 pub type ComponentExtrinsic<C> = <ComponentBlock<C> as BlockT>::Extrinsic;
 
 /// Extrinsic pool API type for `Components`.
-pub type PoolApi<C> = <C as Components>::ExtrinsicPoolApi;
+pub type PoolApi<C> = <C as Components>::TransactionPoolApi;
 
 /// A set of traits for the runtime genesis config.
 pub trait RuntimeGenesis: Serialize + DeserializeOwned + BuildStorage {}
@@ -124,9 +124,9 @@ pub trait ServiceFactory: 'static {
 	/// Chain runtime.
 	type RuntimeDispatch: NativeExecutionDispatch + Send + Sync + 'static;
 	/// Extrinsic pool backend type for the full client.
-	type FullExtrinsicPoolApi: extrinsic_pool::ChainApi<Hash=Self::ExtrinsicHash, Block=Self::Block> + Send + 'static;
+	type FullTransactionPoolApi: transaction_pool::ChainApi<Hash=Self::ExtrinsicHash, Block=Self::Block> + Send + 'static;
 	/// Extrinsic pool backend type for the light client.
-	type LightExtrinsicPoolApi: extrinsic_pool::ChainApi<Hash=Self::ExtrinsicHash, Block=Self::Block> + 'static;
+	type LightTransactionPoolApi: transaction_pool::ChainApi<Hash=Self::ExtrinsicHash, Block=Self::Block> + 'static;
 	/// Genesis configuration for the runtime.
 	type Genesis: RuntimeGenesis;
 	/// Other configuration for service members.
@@ -135,13 +135,13 @@ pub trait ServiceFactory: 'static {
 	/// Network protocol id.
 	const NETWORK_PROTOCOL_ID: network::ProtocolId;
 
-	//TODO: replace these with a constructor trait. that ExtrinsicPool implements.
+	//TODO: replace these with a constructor trait. that TransactionPool implements.
 	/// Extrinsic pool constructor for the full client.
-	fn build_full_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<FullClient<Self>>)
-		-> Result<ExtrinsicPool<Self::FullExtrinsicPoolApi>, error::Error>;
+	fn build_full_transaction_pool(config: TransactionPoolOptions, client: Arc<FullClient<Self>>)
+		-> Result<TransactionPool<Self::FullTransactionPoolApi>, error::Error>;
 	/// Extrinsic pool constructor for the light client.
-	fn build_light_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<LightClient<Self>>)
-		-> Result<ExtrinsicPool<Self::LightExtrinsicPoolApi>, error::Error>;
+	fn build_light_transaction_pool(config: TransactionPoolOptions, client: Arc<LightClient<Self>>)
+		-> Result<TransactionPool<Self::LightTransactionPoolApi>, error::Error>;
 
 	/// Build network protocol.
 	fn build_network_protocol(config: &FactoryFullConfiguration<Self>)
@@ -157,7 +157,7 @@ pub trait Components: 'static {
 	/// Client executor.
 	type Executor: 'static + client::CallExecutor<FactoryBlock<Self::Factory>, Blake2Hasher, RlpCodec> + Send + Sync;
 	/// Extrinsic pool type.
-	type ExtrinsicPoolApi: 'static + extrinsic_pool::ChainApi<Hash=<Self::Factory as ServiceFactory>::ExtrinsicHash, Block=FactoryBlock<Self::Factory>>;
+	type TransactionPoolApi: 'static + transaction_pool::ChainApi<Hash=<Self::Factory as ServiceFactory>::ExtrinsicHash, Block=FactoryBlock<Self::Factory>>;
 
 	/// Create client.
 	fn build_client(
@@ -170,8 +170,8 @@ pub trait Components: 'static {
 		), error::Error>;
 
 	/// Create extrinsic pool.
-	fn build_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<ComponentClient<Self>>)
-		-> Result<ExtrinsicPool<Self::ExtrinsicPoolApi>, error::Error>;
+	fn build_transaction_pool(config: TransactionPoolOptions, client: Arc<ComponentClient<Self>>)
+		-> Result<TransactionPool<Self::TransactionPoolApi>, error::Error>;
 }
 
 /// A struct that implement `Components` for the full client.
@@ -183,7 +183,7 @@ impl<Factory: ServiceFactory> Components for FullComponents<Factory> {
 	type Factory = Factory;
 	type Executor = FullExecutor<Factory>;
 	type Backend = FullBackend<Factory>;
-	type ExtrinsicPoolApi = <Factory as ServiceFactory>::FullExtrinsicPoolApi;
+	type TransactionPoolApi = <Factory as ServiceFactory>::FullTransactionPoolApi;
 
 	fn build_client(
 		config: &FactoryFullConfiguration<Factory>,
@@ -202,10 +202,10 @@ impl<Factory: ServiceFactory> Components for FullComponents<Factory> {
 		Ok((Arc::new(client_db::new_client(db_settings, executor, &config.chain_spec, config.execution_strategy)?), None))
 	}
 
-	fn build_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<ComponentClient<Self>>)
-		-> Result<ExtrinsicPool<Self::ExtrinsicPoolApi>, error::Error>
+	fn build_transaction_pool(config: TransactionPoolOptions, client: Arc<ComponentClient<Self>>)
+		-> Result<TransactionPool<Self::TransactionPoolApi>, error::Error>
 	{
-		Factory::build_full_extrinsic_pool(config, client)
+		Factory::build_full_transaction_pool(config, client)
 	}
 }
 
@@ -222,7 +222,7 @@ impl<Factory: ServiceFactory> Components for LightComponents<Factory>
 	type Factory = Factory;
 	type Executor = LightExecutor<Factory>;
 	type Backend = LightBackend<Factory>;
-	type ExtrinsicPoolApi = <Factory as ServiceFactory>::LightExtrinsicPoolApi;
+	type TransactionPoolApi = <Factory as ServiceFactory>::LightTransactionPoolApi;
 
 	fn build_client(
 		config: &FactoryFullConfiguration<Factory>,
@@ -248,9 +248,9 @@ impl<Factory: ServiceFactory> Components for LightComponents<Factory>
 		Ok((Arc::new(client), Some(fetcher)))
 	}
 
-	fn build_extrinsic_pool(config: ExtrinsicPoolOptions, client: Arc<ComponentClient<Self>>)
-		-> Result<ExtrinsicPool<Self::ExtrinsicPoolApi>, error::Error>
+	fn build_transaction_pool(config: TransactionPoolOptions, client: Arc<ComponentClient<Self>>)
+		-> Result<TransactionPool<Self::TransactionPoolApi>, error::Error>
 	{
-		Factory::build_light_extrinsic_pool(config, client)
+		Factory::build_light_transaction_pool(config, client)
 	}
 }

substrate/core/service/src/config.rs

@@ -17,7 +17,7 @@
 //! Service configuration.
 
 use std::net::SocketAddr;
-use extrinsic_pool;
+use transaction_pool;
 use chain_spec::ChainSpec;
 pub use client::ExecutionStrategy;
 pub use network::Roles;
@@ -38,7 +38,7 @@ pub struct Configuration<C, G: Serialize + DeserializeOwned + BuildStorage> {
 	/// Node roles.
 	pub roles: Roles,
 	/// Extrinsic pool configuration.
-	pub extrinsic_pool: extrinsic_pool::Options,
+	pub transaction_pool: transaction_pool::Options,
 	/// Network configuration.
 	pub network: NetworkConfiguration,
 	/// Path to key files.
@@ -77,7 +77,7 @@ impl<C: Default, G: Serialize + DeserializeOwned + BuildStorage> Configuration<C
 			chain_spec,
 			name: Default::default(),
 			roles: Roles::FULL,
-			extrinsic_pool: Default::default(),
+			transaction_pool: Default::default(),
 			network: Default::default(),
 			keystore_path: Default::default(),
 			database_path: Default::default(),

substrate/core/service/src/lib.rs

@@ -33,7 +33,7 @@ extern crate substrate_executor;
 extern crate substrate_client as client;
 extern crate substrate_client_db as client_db;
 extern crate parity_codec as codec;
-extern crate substrate_extrinsic_pool as extrinsic_pool;
+extern crate substrate_transaction_pool as transaction_pool;
 extern crate substrate_rpc;
 extern crate substrate_rpc_servers as rpc;
 extern crate target_info;
@@ -73,7 +73,7 @@ use codec::{Encode, Decode};
 pub use self::error::{ErrorKind, Error};
 pub use config::{Configuration, Roles, PruningMode};
 pub use chain_spec::ChainSpec;
-pub use extrinsic_pool::{Pool as ExtrinsicPool, Options as ExtrinsicPoolOptions, ChainApi, VerifiedTransaction, IntoPoolError};
+pub use transaction_pool::{Pool as TransactionPool, Options as TransactionPoolOptions, ChainApi, VerifiedTransaction, IntoPoolError};
 pub use client::ExecutionStrategy;
 
 pub use components::{ServiceFactory, FullBackend, FullExecutor, LightBackend,
@@ -88,7 +88,7 @@ pub use components::{ServiceFactory, FullBackend, FullExecutor, LightBackend,
 pub struct Service<Components: components::Components> {
 	client: Arc<ComponentClient<Components>>,
 	network: Option<Arc<components::NetworkService<Components::Factory>>>,
-	extrinsic_pool: Arc<ExtrinsicPool<Components::ExtrinsicPoolApi>>,
+	transaction_pool: Arc<TransactionPool<Components::TransactionPoolApi>>,
 	keystore: Keystore,
 	exit: ::exit_future::Exit,
 	signal: Option<Signal>,
@@ -150,12 +150,12 @@ impl<Components> Service<Components>
 		telemetry!("node.start"; "height" => best_header.number().as_(), "best" => ?best_header.hash());
 
 		let network_protocol = <Components::Factory>::build_network_protocol(&config)?;
-		let extrinsic_pool = Arc::new(
-			Components::build_extrinsic_pool(config.extrinsic_pool, client.clone())?
+		let transaction_pool = Arc::new(
+			Components::build_transaction_pool(config.transaction_pool, client.clone())?
 		);
-		let extrinsic_pool_adapter = ExtrinsicPoolAdapter::<Components> {
+		let transaction_pool_adapter = TransactionPoolAdapter::<Components> {
 			imports_external_transactions: !config.roles == Roles::LIGHT,
-			pool: extrinsic_pool.clone(),
+			pool: transaction_pool.clone(),
 			client: client.clone(),
 		 };
 
@@ -167,7 +167,7 @@ impl<Components> Service<Components>
 			chain: client.clone(),
 			on_demand: on_demand.clone()
 				.map(|d| d as Arc<network::OnDemandService<ComponentBlock<Components>>>),
-			transaction_pool: Arc::new(extrinsic_pool_adapter),
+			transaction_pool: Arc::new(transaction_pool_adapter),
 			specialization: network_protocol,
 		};
 
@@ -177,7 +177,7 @@ impl<Components> Service<Components>
 		{
 			// block notifications
 			let network = network.clone();
-			let txpool = extrinsic_pool.clone();
+			let txpool = transaction_pool.clone();
 
 			let events = client.import_notification_stream()
 				.for_each(move |notification| {
@@ -194,7 +194,7 @@ impl<Components> Service<Components>
 		{
 			// extrinsic notifications
 			let network = network.clone();
-			let events = extrinsic_pool.import_notification_stream()
+			let events = transaction_pool.import_notification_stream()
 				// TODO [ToDr] Consider throttling?
 				.for_each(move |_| {
 					network.trigger_repropagate();
@@ -218,7 +218,7 @@ impl<Components> Service<Components>
 				let client = client.clone();
 				let chain = rpc::apis::chain::Chain::new(client.clone(), task_executor.clone());
 				let state = rpc::apis::state::State::new(client.clone(), task_executor.clone());
-				let author = rpc::apis::author::Author::new(client.clone(), extrinsic_pool.clone(), task_executor.clone());
+				let author = rpc::apis::author::Author::new(client.clone(), transaction_pool.clone(), task_executor.clone());
 				rpc::rpc_handler::<ComponentBlock<Components>, ComponentExHash<Components>, _, _, _, _, _>(
 					state,
 					chain,
@@ -262,7 +262,7 @@ impl<Components> Service<Components>
 		Ok(Service {
 			client: client,
 			network: Some(network),
-			extrinsic_pool: extrinsic_pool,
+			transaction_pool: transaction_pool,
 			signal: Some(signal),
 			keystore: keystore,
 			exit,
@@ -283,8 +283,8 @@ impl<Components> Service<Components>
 	}
 
 	/// Get shared extrinsic pool instance.
-	pub fn extrinsic_pool(&self) -> Arc<ExtrinsicPool<Components::ExtrinsicPoolApi>> {
-		self.extrinsic_pool.clone()
+	pub fn transaction_pool(&self) -> Arc<TransactionPool<Components::TransactionPoolApi>> {
+		self.transaction_pool.clone()
 	}
 
 	/// Get shared keystore.
@@ -350,13 +350,13 @@ impl substrate_rpc::system::SystemApi for RpcConfig {
 }
 
 /// Transaction pool adapter.
-pub struct ExtrinsicPoolAdapter<C: Components> {
+pub struct TransactionPoolAdapter<C: Components> {
 	imports_external_transactions: bool,
-	pool: Arc<ExtrinsicPool<C::ExtrinsicPoolApi>>,
+	pool: Arc<TransactionPool<C::TransactionPoolApi>>,
 	client: Arc<ComponentClient<C>>,
 }
 
-impl<C: Components> ExtrinsicPoolAdapter<C> {
+impl<C: Components> TransactionPoolAdapter<C> {
 	fn best_block_id(&self) -> Option<BlockId<ComponentBlock<C>>> {
 		self.client.info()
 			.map(|info| BlockId::hash(info.chain.best_hash))
@@ -367,7 +367,7 @@ impl<C: Components> ExtrinsicPoolAdapter<C> {
 	}
 }
 
-impl<C: Components> network::TransactionPool<ComponentExHash<C>, ComponentBlock<C>> for ExtrinsicPoolAdapter<C> {
+impl<C: Components> network::TransactionPool<ComponentExHash<C>, ComponentBlock<C>> for TransactionPoolAdapter<C> {
 	fn transactions(&self) -> Vec<(ComponentExHash<C>, ComponentExtrinsic<C>)> {
 		let best_block_id = match self.best_block_id() {
 			Some(id) => id,
@@ -398,7 +398,7 @@ impl<C: Components> network::TransactionPool<ComponentExHash<C>, ComponentBlock<
 				Ok(xt) => Some(*xt.hash()),
 				Err(e) => match e.into_pool_error() {
 					Ok(e) => match e.kind() {
-						extrinsic_pool::ErrorKind::AlreadyImported(hash) =>
+						transaction_pool::ErrorKind::AlreadyImported(hash) =>
 							Some(::std::str::FromStr::from_str(&hash).map_err(|_| {})
 								.expect("Hash string is always valid")),
 						_ => {