Handle AccountIndices in transaction pool (#225)

* Merge remote-tracking branch 'origin/master' into gav-xts-dont-panic

* Update wasm.

* consensus, session and staking all panic-safe.

* Democracy doesn't panic in apply.

* Fix tests.

* Extra helper macro, council depanicked.

* Fix one test.

* Fix up all council tests. No panics!

* Council voting depanicked.

* Dispatch returns result.

* session & staking tests updated

* Fix democracy tests.

* Fix council tests.

* Fix up polkadot parachains in runtime

* Fix borked merge

* More Slicable support

Support general `Option` and array types.

* Basic storage types.

* Existential deposit for contract creation

* Basic implemnetation along with removals

* Fix tests.

* externalities builder fix.

* Tests.

* Fix up the runtime.

* Fix tests.

* Add generic `Address` type.

* Initial function integration of Address into Extrinsic.

* Fix build

* All tests compile.

* Fix (some) tests.

* Fix signing.

* Push error.

* transfer can accept Address

* Make Address generic over AccountIndex

* Fix test

* Make Council use Address for dispatch.

* Fix build

* Bend over backwards to support braindead derive.

* Repot some files.

* Fix tests.

* Fix grumbles

* Remove Default bound

* Fix build for new nightly.

* Make `apply_extrinsic` never panic, return useful Result.

* More merge hell

* Doesn't build, but might do soon

* Serde woes

* get substrate-runtime-staking compiling

* Polkadot builds again!

* Fix all build.

* Fix tests & binaries.

* Reserve some extra initial byte values of address for future format changes

* Make semantic of `ReservedBalance` clear.

* Fix panic handler.

* Integrate other balance transformations into the new model

Fix up staking tests.

* Fix runtime tests.

* Fix panic build.

* Tests for demonstrating interaction between balance types.

* Repot some runtime code

* Fix checkedblock in non-std builds

* Get rid of `DoLookup` phantom.

* Attempt to make transaction_pool work with lookups.

* Remove vscode settings

* New attempt at making transaction pool work.

* It builds again!

* --all builds

* Fix tests.

* New build.

* Test account nonce reset.

* polkadot transaction pool tests/framework.

* Address grumbles.

* Pool support non-verified transactions.

* Revert bad `map_or`

* Rebuild binaries, workaround.

* Avoid casting to usize early.

* Make verification use provided block_id.

* Fix tests.

* Alter tests to use retry.

* Fix tests & add call to re-verify.

* Semi-refactor.

* Integrate new queue with the rest of the code.

* Fix tests.

* Add reverify_transaction method.

* Use result.

substrate/substrate/rpc/src/author/mod.rs

@@ -17,8 +17,13 @@
 //! Substrate block-author/full-node API.
 
 use std::sync::Arc;
+
+use client::{self, Client};
 use extrinsic_pool::api::{Error, ExtrinsicPool};
 
+use runtime_primitives::{generic, traits::Block as BlockT};
+use state_machine;
+
 pub mod error;
 
 #[cfg(test)]
@@ -35,13 +40,34 @@ build_rpc_trait! {
 	}
 }
 
-impl<Ex, Hash, T> AuthorApi<Hash, Ex> for Arc<T> where
-	T: ExtrinsicPool<Ex, Hash>,
-	T::Error: 'static,
+/// Authoring API
+pub struct Author<B, E, Block: BlockT, P> {
+	/// Substrate client
+	client: Arc<Client<B, E, Block>>,
+	/// Extrinsic pool
+	pool: Arc<P>,
+}
+
+impl<B, E, Block: BlockT, P> Author<B, E, Block, P> {
+	/// Create new instance of Authoring API.
+	pub fn new(client: Arc<Client<B, E, Block>>, pool: Arc<P>) -> Self {
+		Author { client, pool }
+	}
+}
+
+
+impl<B, E, Block, P, Ex, Hash> AuthorApi<Hash, Ex> for Author<B, E, Block, P> where
+	B: client::backend::Backend<Block> + Send + Sync + 'static,
+	E: client::CallExecutor<Block> + Send + Sync + 'static,
+	Block: BlockT + 'static,
+	client::error::Error: From<<<B as client::backend::Backend<Block>>::State as state_machine::backend::Backend>::Error>,
+	P: ExtrinsicPool<Ex, generic::BlockId<Block>, Hash>,
+	P::Error: 'static,
 {
 	fn submit_extrinsic(&self, xt: Ex) -> Result<Hash> {
-		self
-			.submit(vec![xt])
+		let best_block_hash = self.client.info().unwrap().chain.best_hash;
+		self.pool
+			.submit(generic::BlockId::hash(best_block_hash), vec![xt])
 			.map(|mut res| res.pop().expect("One extrinsic passed; one result back; qed"))
 			.map_err(|e| e.into_pool_error()
 				.map(Into::into)