Reorganising the repository - external renames and moves (#4074)

* Adding first rough ouline of the repository structure * Remove old CI stuff * add title * formatting fixes * move node-exits job's script to scripts dir * Move docs into subdir * move to bin * move maintainence scripts, configs and helpers into its own dir * add .local to ignore * move core->client * start up 'test' area * move test client * move test runtime * make test move compile * Add dependencies rule enforcement. * Fix indexing. * Update docs to reflect latest changes * Moving /srml->/paint * update docs * move client/sr-* -> primitives/ * clean old readme * remove old broken code in rhd * update lock * Step 1. * starting to untangle client * Fix after merge. * start splitting out client interfaces * move children and blockchain interfaces * Move trie and state-machine to primitives. * Fix WASM builds. * fixing broken imports * more interface moves * move backend and light to interfaces * move CallExecutor * move cli off client * moving around more interfaces * re-add consensus crates into the mix * fix subkey path * relieve client from executor * starting to pull out client from grandpa * move is_decendent_of out of client * grandpa still depends on client directly * lemme tests pass * rename srml->paint * Make it compile. * rename interfaces->client-api * Move keyring to primitives. * fixup libp2p dep * fix broken use * allow dependency enforcement to fail * move fork-tree * Moving wasm-builder * make env * move build-script-utils * fixup broken crate depdencies and names * fix imports for authority discovery * fix typo * update cargo.lock * fixing imports * Fix paths and add missing crates * re-add missing crates
2026-06-14 13:21:10 +00:00 · 2019-11-14 21:51:17 +01:00
parent becc3b0a4f
commit 60e5011c72
809 changed files with 7801 additions and 6464 deletions
@@ -0,0 +1,112 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Chain api required for the transaction pool.
+
+use std::{marker::PhantomData, pin::Pin, sync::Arc};
+
+use codec::Encode;
+
+use futures::{channel::oneshot, executor::{ThreadPool, ThreadPoolBuilder}, future::Future};
+
+use primitives::{H256, Blake2Hasher, Hasher};
+
+use sr_primitives::{generic::BlockId, traits, transaction_validity::TransactionValidity};
+
+use tx_runtime_api::TaggedTransactionQueue;
+
+use crate::error::{self, Error};
+
+/// The transaction pool logic
+pub struct FullChainApi<T, Block> {
+	client: Arc<T>,
+	pool: ThreadPool,
+	_marker: PhantomData<Block>,
+}
+
+impl<T, Block> FullChainApi<T, Block> where
+	Block: traits::Block,
+	T: traits::ProvideRuntimeApi + traits::BlockIdTo<Block> {
+	/// Create new transaction pool logic.
+	pub fn new(client: Arc<T>) -> Self {
+		FullChainApi {
+			client,
+			pool: ThreadPoolBuilder::new()
+				.pool_size(2)
+				.name_prefix("txpool-verifier")
+				.create()
+				.expect("Failed to spawn verifier threads, that are critical for node operation."),
+			_marker: Default::default()
+		}
+	}
+}
+
+impl<T, Block> txpool::ChainApi for FullChainApi<T, Block> where
+	Block: traits::Block<Hash = H256>,
+	T: traits::ProvideRuntimeApi + traits::BlockIdTo<Block> + 'static + Send + Sync,
+	T::Api: TaggedTransactionQueue<Block>,
+	sr_api::ApiErrorFor<T, Block>: Send,
+{
+	type Block = Block;
+	type Hash = H256;
+	type Error = error::Error;
+	type ValidationFuture = Pin<Box<dyn Future<Output = error::Result<TransactionValidity>> + Send>>;
+
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		uxt: txpool::ExtrinsicFor<Self>,
+	) -> Self::ValidationFuture {
+		let (tx, rx) = oneshot::channel();
+		let client = self.client.clone();
+		let at = at.clone();
+
+		self.pool.spawn_ok(async move {
+			let res = client.runtime_api().validate_transaction(&at, uxt)
+				.map_err(|e| Error::RuntimeApi(format!("{:?}", e)));
+			if let Err(e) = tx.send(res) {
+				log::warn!("Unable to send a validate transaction result: {:?}", e);
+			}
+		});
+
+		Box::pin(async move {
+			match rx.await {
+				Ok(r) => r,
+				Err(_) => Err(Error::RuntimeApi("Validation was canceled".into())),
+			}
+		})
+	}
+
+	fn block_id_to_number(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> error::Result<Option<txpool::NumberFor<Self>>> {
+		self.client.to_number(at).map_err(|e| Error::BlockIdConversion(format!("{:?}", e)))
+	}
+
+	fn block_id_to_hash(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> error::Result<Option<txpool::BlockHash<Self>>> {
+		self.client.to_hash(at).map_err(|e| Error::BlockIdConversion(format!("{:?}", e)))
+	}
+
+	fn hash_and_length(&self, ex: &txpool::ExtrinsicFor<Self>) -> (Self::Hash, usize) {
+		ex.using_encoded(|x| {
+			(Blake2Hasher::hash(x), x.len())
+		})
+	}
+}
@@ -0,0 +1,50 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Transaction pool error.
+
+/// Transaction pool result.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Transaction pool error type.
+#[derive(Debug, derive_more::Display, derive_more::From)]
+pub enum Error {
+	/// Pool error.
+	Pool(txpool::error::Error),
+	/// Error while converting a `BlockId`.
+	BlockIdConversion(String),
+	/// Error while calling the runtime api.
+	RuntimeApi(String),
+}
+
+impl std::error::Error for Error {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		match self {
+			Error::Pool(ref err) => Some(err),
+			Error::BlockIdConversion(_) => None,
+			Error::RuntimeApi(_) => None,
+		}
+	}
+}
+
+impl txpool::IntoPoolError for Error {
+	fn into_pool_error(self) -> std::result::Result<txpool::error::Error, Self> {
+		match self {
+			Error::Pool(e) => Ok(e),
+			e => Err(e),
+		}
+	}
+}
@@ -0,0 +1,28 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate transaction pool.
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+mod api;
+pub mod error;
+#[cfg(test)]
+mod tests;
+
+pub use api::FullChainApi;
+pub use txpool;
@@ -0,0 +1,222 @@
+// Copyright 2018-2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+
+use super::*;
+
+use codec::Encode;
+use futures::executor::block_on;
+use txpool::{self, Pool};
+use test_client::{runtime::{AccountId, Block, Hash, Index, Extrinsic, Transfer}, AccountKeyring::{self, *}};
+use sr_primitives::{
+	generic::{self, BlockId},
+	traits::{Hash as HashT, BlakeTwo256},
+	transaction_validity::{TransactionValidity, ValidTransaction},
+};
+
+struct TestApi {
+	pub modifier: Box<dyn Fn(&mut ValidTransaction) + Send + Sync>,
+}
+
+impl TestApi {
+	fn default() -> Self {
+		TestApi {
+			modifier: Box::new(|_| {}),
+		}
+	}
+}
+
+impl txpool::ChainApi for TestApi {
+	type Block = Block;
+	type Hash = Hash;
+	type Error = error::Error;
+	type ValidationFuture = futures::future::Ready<error::Result<TransactionValidity>>;
+
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		uxt: txpool::ExtrinsicFor<Self>,
+	) -> Self::ValidationFuture {
+		let expected = index(at);
+		let requires = if expected == uxt.transfer().nonce {
+			vec![]
+		} else {
+			vec![vec![uxt.transfer().nonce as u8 - 1]]
+		};
+		let provides = vec![vec![uxt.transfer().nonce as u8]];
+
+		let mut validity = ValidTransaction {
+			priority: 1,
+			requires,
+			provides,
+			longevity: 64,
+			propagate: true,
+		};
+
+		(self.modifier)(&mut validity);
+
+		futures::future::ready(Ok(
+			Ok(validity)
+		))
+	}
+
+	fn block_id_to_number(&self, at: &BlockId<Self::Block>) -> error::Result<Option<txpool::NumberFor<Self>>> {
+		Ok(Some(number_of(at)))
+	}
+
+	fn block_id_to_hash(&self, at: &BlockId<Self::Block>) -> error::Result<Option<txpool::BlockHash<Self>>> {
+		Ok(match at {
+			generic::BlockId::Hash(x) => Some(x.clone()),
+			_ => Some(Default::default()),
+		})
+	}
+
+	fn hash_and_length(&self, ex: &txpool::ExtrinsicFor<Self>) -> (Self::Hash, usize) {
+		let encoded = ex.encode();
+		(BlakeTwo256::hash(&encoded), encoded.len())
+	}
+
+}
+
+fn index(at: &BlockId<Block>) -> u64 {
+	209 + number_of(at)
+}
+
+fn number_of(at: &BlockId<Block>) -> u64 {
+	match at {
+		generic::BlockId::Number(n) => *n as u64,
+		_ => 0,
+	}
+}
+
+fn uxt(who: AccountKeyring, nonce: Index) -> Extrinsic {
+	let transfer = Transfer {
+		from: who.into(),
+		to: AccountId::default(),
+		nonce,
+		amount: 1,
+	};
+	let signature = transfer.using_encoded(|e| who.sign(e));
+	Extrinsic::Transfer(transfer, signature.into())
+}
+
+fn pool() -> Pool<TestApi> {
+	Pool::new(Default::default(), TestApi::default())
+}
+
+#[test]
+fn submission_should_work() {
+	let pool = pool();
+	assert_eq!(209, index(&BlockId::number(0)));
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 209))).unwrap();
+
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, vec![209]);
+}
+
+#[test]
+fn multiple_submission_should_work() {
+	let pool = pool();
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 209))).unwrap();
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 210))).unwrap();
+
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, vec![209, 210]);
+}
+
+#[test]
+fn early_nonce_should_be_culled() {
+	let pool = pool();
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 208))).unwrap();
+
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, Vec::<Index>::new());
+}
+
+#[test]
+fn late_nonce_should_be_queued() {
+	let pool = pool();
+
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 210))).unwrap();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, Vec::<Index>::new());
+
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 209))).unwrap();
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, vec![209, 210]);
+}
+
+#[test]
+fn prune_tags_should_work() {
+	let pool = pool();
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 209))).unwrap();
+	block_on(pool.submit_one(&BlockId::number(0), uxt(Alice, 210))).unwrap();
+
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, vec![209, 210]);
+
+	block_on(pool.prune_tags(&BlockId::number(1), vec![vec![209]], vec![])).unwrap();
+
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, vec![210]);
+}
+
+#[test]
+fn should_ban_invalid_transactions() {
+	let pool = pool();
+	let uxt = uxt(Alice, 209);
+	let hash = block_on(pool.submit_one(&BlockId::number(0), uxt.clone())).unwrap();
+	pool.remove_invalid(&[hash]);
+	block_on(pool.submit_one(&BlockId::number(0), uxt.clone())).unwrap_err();
+
+	// when
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, Vec::<Index>::new());
+
+	// then
+	block_on(pool.submit_one(&BlockId::number(0), uxt.clone())).unwrap_err();
+}
+
+#[test]
+fn should_correctly_prune_transactions_providing_more_than_one_tag() {
+	let mut api = TestApi::default();
+	api.modifier = Box::new(|v: &mut ValidTransaction| {
+		v.provides.push(vec![155]);
+	});
+	let pool = Pool::new(Default::default(), api);
+	let xt = uxt(Alice, 209);
+	block_on(pool.submit_one(&BlockId::number(0), xt.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	// remove the transaction that just got imported.
+	block_on(pool.prune_tags(&BlockId::number(1), vec![vec![209]], vec![])).expect("1. Pruned");
+	assert_eq!(pool.status().ready, 0);
+	// it's re-imported to future
+	assert_eq!(pool.status().future, 1);
+
+	// so now let's insert another transaction that also provides the 155
+	let xt = uxt(Alice, 211);
+	block_on(pool.submit_one(&BlockId::number(2), xt.clone())).expect("2. Imported");
+	assert_eq!(pool.status().ready, 1);
+	assert_eq!(pool.status().future, 1);
+	let pending: Vec<_> = pool.ready().map(|a| a.data.transfer().nonce).collect();
+	assert_eq!(pending, vec![211]);
+
+	// prune it and make sure the pool is empty
+	block_on(pool.prune_tags(&BlockId::number(3), vec![vec![155]], vec![])).expect("2. Pruned");
+	assert_eq!(pool.status().ready, 0);
+	assert_eq!(pool.status().future, 2);
+}