Implement runtime api client side directly in the runtime (#1094)

* Move `initialise_block` into `Core` trait as it is crucial calling the API functions

* Switch to first version of new runtime API implementation

* Fixes bug in tests

* Reenable asserts

* Directly use the `TestAPI` in the tests

* Start improving the api traits

:100644 100644 898aadc7 49217199 M	Cargo.lock
:100644 100644 61570436 465ed664 M	core/client/src/backend.rs
:100644 100644 5d0c886b 64d710fd M	core/client/src/block_builder.rs
:100644 100644 c447855e 5ecbe474 M	core/client/src/client.rs
:100644 100644 139cef13 f90dbf3d M	core/client/src/error.rs
:100644 100644 2800c503 3298e66a M	core/client/src/runtime_api.rs
:100644 100644 affa1c5c 809b08bc M	core/primitives/src/lib.rs
:100644 100644 2877dfa9 d5547413 M	core/sr-api/Cargo.toml
:100644 100644 9a49784d 6a625a03 M	core/sr-api/src/lib.rs
:100644 100644 7c28e1c7 a1a444a9 M	core/sr-primitives/src/traits.rs
:100644 100644 2e113ab6 dcc01a6d M	srml/metadata/Cargo.toml
:100644 100644 ea722a70 0809531a M	srml/metadata/src/lib.rs

* Refactoring

* Move `sr-api` into client and more refactoring

* Fixes tests

* Some documentation and cleanup

* Fixes compilation after rebase

* More refactoring and more documentation

* Makes `substrate-client` compilable on `wasm`

On `wasm` it basically just exports the runtime api stuff.

* Fixes grumbles

* Updates wasm files after rebasing the master

* Remove TODO comment

* Remove whitespaces

* Fixes after rebasing master

* Another rebase, another fix commit

substrate/node/cli/src/lib.rs

@@ -33,6 +33,7 @@ extern crate substrate_transaction_pool as transaction_pool;
 #[macro_use]
 extern crate substrate_network as network;
 extern crate substrate_consensus_aura as consensus;
+extern crate substrate_client as client;
 extern crate node_primitives;
 #[macro_use]
 extern crate substrate_service;
@@ -49,6 +50,7 @@ mod service;
 use tokio::runtime::Runtime;
 pub use cli::{VersionInfo, IntoExit};
 use substrate_service::{ServiceFactory, Roles as ServiceRoles};
+use std::ops::Deref;
 
 /// The chain specification option.
 #[derive(Clone, Debug)]
@@ -118,12 +120,13 @@ pub fn run<I, T, E>(args: I, exit: E, version: cli::VersionInfo) -> error::Resul
 	Ok(())
 }
 
-fn run_until_exit<C, E>(
+fn run_until_exit<T, C, E>(
 	runtime: &mut Runtime,
-	service: service::Service<C>,
+	service: T,
 	e: E,
 ) -> error::Result<()>
 	where
+	    T: Deref<Target=substrate_service::Service<C>>,
 		C: substrate_service::Components,
 		E: IntoExit,
 {

substrate/node/cli/src/service.rs

@@ -20,8 +20,8 @@
 
 use std::sync::Arc;
 use transaction_pool::{self, txpool::{Pool as TransactionPool}};
+use node_runtime::{GenesisConfig, ClientWithApi};
 use node_primitives::Block;
-use node_runtime::GenesisConfig;
 use substrate_service::{
 	FactoryFullConfiguration, LightComponents, FullComponents, FullBackend,
 	FullClient, LightClient, LightBackend, FullExecutor, LightExecutor,
@@ -29,6 +29,7 @@ use substrate_service::{
 };
 use node_executor;
 use consensus::{import_queue, start_aura, Config as AuraConfig, AuraImportQueue};
+use client;
 
 const AURA_SLOT_DURATION: u64 = 6;
 
@@ -37,23 +38,22 @@ construct_simple_protocol! {
 	pub struct NodeProtocol where Block = Block { }
 }
 
-construct_simple_service!(Service);
-
 construct_service_factory! {
 	struct Factory {
 		Block = Block,
+		RuntimeApi = ClientWithApi,
 		NetworkProtocol = NodeProtocol { |config| Ok(NodeProtocol::new()) },
 		RuntimeDispatch = node_executor::Executor,
-		FullTransactionPoolApi = transaction_pool::ChainApi<FullBackend<Self>, FullExecutor<Self>, Block>
+		FullTransactionPoolApi = transaction_pool::ChainApi<client::Client<FullBackend<Self>, FullExecutor<Self>, Block, ClientWithApi>, Block>
 			{ |config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client))) },
-		LightTransactionPoolApi = transaction_pool::ChainApi<LightBackend<Self>, LightExecutor<Self>, Block>
+		LightTransactionPoolApi = transaction_pool::ChainApi<client::Client<LightBackend<Self>, LightExecutor<Self>, Block, ClientWithApi>, Block>
 			{ |config, client| Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client))) },
 		Genesis = GenesisConfig,
 		Configuration = (),
-		FullService = Service<FullComponents<Self>>
+		FullService = FullComponents<Self>
 			{ |config: FactoryFullConfiguration<Self>, executor: TaskExecutor| {
 				let is_auth = config.roles == Roles::AUTHORITY;
-				Service::<FullComponents<Factory>>::new(config, executor.clone()).map(move |service|{
+				FullComponents::<Factory>::new(config, executor.clone()).map(move |service|{
 					if is_auth {
 						if let Ok(Some(Ok(key))) = service.keystore().contents()
 							.map(|keys| keys.get(0).map(|k| service.keystore().load(k, "")))
@@ -77,18 +77,20 @@ construct_service_factory! {
 				})
 			}
 		},
-		LightService = Service<LightComponents<Self>>
-			{ |config, executor| Service::<LightComponents<Factory>>::new(config, executor) },
+		LightService = LightComponents<Self>
+			{ |config, executor| <LightComponents<Factory>>::new(config, executor) },
 		FullImportQueue = AuraImportQueue<Self::Block, FullClient<Self>>
 			{ |config, client| Ok(import_queue(AuraConfig {
 						local_key: None,
 						slot_duration: 5
 					}, client)) },
 		LightImportQueue = AuraImportQueue<Self::Block, LightClient<Self>>
-			{ |config, client| Ok(import_queue(AuraConfig {
-						local_key: None,
-						slot_duration: 5
-					}, client)) },
+			{ |config, client| Ok(
+				import_queue(AuraConfig {
+					local_key: None,
+					slot_duration: 5
+				}, client))
+			},
 	}
 }
 

substrate/node/runtime/Cargo.toml

@@ -11,10 +11,10 @@ serde_derive = { version = "1.0", optional = true }
 safe-mix = { version = "1.0", default-features = false }
 parity-codec = "2.1"
 parity-codec-derive = "2.1"
-sr-api = { path = "../../core/sr-api", default-features = false }
 sr-std = { path = "../../core/sr-std" }
 srml-support = { path = "../../srml/support" }
 substrate-primitives = { path = "../../core/primitives" }
+substrate-client = { path = "../../core/client", optional = true }
 substrate-keyring = { path = "../../core/keyring" }
 srml-balances = { path = "../../srml/balances" }
 srml-consensus = { path = "../../srml/consensus" }
@@ -37,7 +37,6 @@ default = ["std"]
 std = [
 	"parity-codec/std",
 	"substrate-primitives/std",
-	"sr-api/std",
 	"sr-std/std",
 	"srml-support/std",
 	"srml-balances/std",
@@ -57,5 +56,6 @@ std = [
 	"node-primitives/std",
 	"serde_derive",
 	"serde/std",
-	"safe-mix/std"
+	"safe-mix/std",
+	"substrate-client",
 ]

substrate/node/runtime/src/lib.rs

@@ -20,9 +20,6 @@
 // `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
 #![recursion_limit="256"]
 
-#[macro_use]
-extern crate sr_api as runtime_api;
-
 #[macro_use]
 extern crate srml_support;
 
@@ -35,9 +32,14 @@ extern crate serde_derive;
 
 extern crate substrate_primitives;
 
+#[macro_use]
+extern crate substrate_client as client;
+
 #[macro_use]
 extern crate parity_codec_derive;
 
+extern crate parity_codec as codec;
+
 extern crate sr_std as rstd;
 extern crate srml_balances as balances;
 extern crate srml_consensus as consensus;
@@ -55,23 +57,33 @@ extern crate srml_upgrade_key as upgrade_key;
 extern crate sr_version as version;
 extern crate node_primitives;
 
+#[cfg(feature = "std")]
+use codec::{Encode, Decode};
 use rstd::prelude::*;
 use substrate_primitives::u32_trait::{_2, _4};
 use node_primitives::{
-	AccountId, AccountIndex, Balance, BlockNumber, Hash, Index,
-	SessionKey, Signature
+	AccountId, AccountIndex, Balance, BlockNumber, Hash, Index, SessionKey, Signature
 };
-use runtime_api::{runtime::*, id::*};
+#[cfg(feature = "std")]
+use node_primitives::Block as GBlock;
+use client::{block_builder::api::runtime::*, runtime_api::{runtime::*, id::*}};
+#[cfg(feature = "std")]
+use client::runtime_api::ApiExt;
 use runtime_primitives::ApplyResult;
 use runtime_primitives::transaction_validity::TransactionValidity;
 use runtime_primitives::generic;
 use runtime_primitives::traits::{Convert, BlakeTwo256, Block as BlockT};
+#[cfg(feature = "std")]
+use runtime_primitives::traits::ApiRef;
+#[cfg(feature = "std")]
+use substrate_primitives::AuthorityId;
 use version::RuntimeVersion;
 use council::{motions as council_motions, voting as council_voting};
 #[cfg(feature = "std")]
 use council::seats as council_seats;
 #[cfg(any(feature = "std", test))]
 use version::NativeVersion;
+use substrate_primitives::OpaqueMetadata;
 
 #[cfg(any(feature = "std", test))]
 pub use runtime_primitives::BuildStorage;
@@ -236,8 +248,155 @@ pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Index, Call>;
 /// Executive: handles dispatch to the various modules.
 pub type Executive = executive::Executive<Runtime, Block, balances::ChainContext<Runtime>, Balances, AllModules>;
 
-impl_apis! {
-	impl Core<Block, SessionKey> for Runtime {
+#[cfg(feature = "std")]
+pub struct ClientWithApi {
+	call: ::std::ptr::NonNull<client::runtime_api::CallApiAt<GBlock>>,
+	commit_on_success: ::std::cell::RefCell<bool>,
+	initialised_block: ::std::cell::RefCell<Option<GBlockId>>,
+	changes: ::std::cell::RefCell<client::runtime_api::OverlayedChanges>,
+}
+
+#[cfg(feature = "std")]
+unsafe impl Send for ClientWithApi {}
+#[cfg(feature = "std")]
+unsafe impl Sync for ClientWithApi {}
+
+#[cfg(feature = "std")]
+impl ApiExt for ClientWithApi {
+	fn map_api_result<F: FnOnce(&Self) -> Result<R, E>, R, E>(&self, map_call: F) -> Result<R, E> {
+		*self.commit_on_success.borrow_mut() = false;
+		let res = map_call(self);
+		*self.commit_on_success.borrow_mut() = true;
+
+		self.commit_on_ok(&res);
+
+		res
+	}
+}
+
+#[cfg(feature = "std")]
+impl client::runtime_api::ConstructRuntimeApi<GBlock> for ClientWithApi {
+	fn construct_runtime_api<'a, T: client::runtime_api::CallApiAt<GBlock>>(call: &'a T) -> ApiRef<'a, Self> {
+		ClientWithApi {
+			call: unsafe {
+				::std::ptr::NonNull::new_unchecked(
+					::std::mem::transmute(
+						call as &client::runtime_api::CallApiAt<GBlock>
+					)
+				)
+			},
+			commit_on_success: true.into(),
+			initialised_block: None.into(),
+			changes: Default::default(),
+		}.into()
+	}
+}
+
+#[cfg(feature = "std")]
+impl ClientWithApi {
+	fn call_api_at<A: Encode, R: Decode>(
+		&self,
+		at: &GBlockId,
+		function: &'static str,
+		args: &A
+	) -> client::error::Result<R> {
+		let res = unsafe {
+			self.call.as_ref().call_api_at(
+				at,
+				function,
+				args.encode(),
+				&mut *self.changes.borrow_mut(),
+				&mut *self.initialised_block.borrow_mut()
+			).and_then(|r|
+				R::decode(&mut &r[..])
+					.ok_or_else(||
+						client::error::ErrorKind::CallResultDecode(function).into()
+					)
+			)
+		};
+
+		self.commit_on_ok(&res);
+		res
+	}
+
+	fn commit_on_ok<R, E>(&self, res: &Result<R, E>) {
+		if *self.commit_on_success.borrow() {
+			if res.is_err() {
+				self.changes.borrow_mut().discard_prospective();
+			} else {
+				self.changes.borrow_mut().commit_prospective();
+			}
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+type GBlockId = generic::BlockId<GBlock>;
+
+#[cfg(feature = "std")]
+impl client::runtime_api::Core<GBlock> for ClientWithApi {
+	fn version(&self, at: &GBlockId) -> Result<RuntimeVersion, client::error::Error> {
+		self.call_api_at(at, "version", &())
+	}
+
+	fn authorities(&self, at: &GBlockId) -> Result<Vec<AuthorityId>, client::error::Error> {
+		self.call_api_at(at, "authorities", &())
+	}
+
+	fn execute_block(&self, at: &GBlockId, block: &GBlock) -> Result<(), client::error::Error> {
+		self.call_api_at(at, "execute_block", block)
+	}
+
+	fn initialise_block(&self, at: &GBlockId, header: &<GBlock as BlockT>::Header) -> Result<(), client::error::Error> {
+		self.call_api_at(at, "initialise_block", header)
+	}
+}
+
+#[cfg(feature = "std")]
+impl client::block_builder::api::BlockBuilder<GBlock> for ClientWithApi {
+	fn apply_extrinsic(&self, at: &GBlockId, extrinsic: &<GBlock as BlockT>::Extrinsic) -> Result<ApplyResult, client::error::Error> {
+		self.call_api_at(at, "apply_extrinsic", extrinsic)
+	}
+
+	fn finalise_block(&self, at: &GBlockId) -> Result<<GBlock as BlockT>::Header, client::error::Error> {
+		self.call_api_at(at, "finalise_block", &())
+	}
+
+	fn inherent_extrinsics<Inherent: Decode + Encode, Unchecked: Decode + Encode>(
+		&self, at: &GBlockId, inherent: &Inherent
+	) -> Result<Vec<Unchecked>, client::error::Error> {
+		self.call_api_at(at, "inherent_extrinsics", inherent)
+	}
+
+	fn check_inherents<Inherent: Decode + Encode, Error: Decode + Encode>(&self, at: &GBlockId, block: &GBlock, inherent: &Inherent) -> Result<Result<(), Error>, client::error::Error> {
+		self.call_api_at(at, "check_inherents", &(block, inherent))
+	}
+
+	fn random_seed(&self, at: &GBlockId) -> Result<<GBlock as BlockT>::Hash, client::error::Error> {
+		self.call_api_at(at, "random_seed", &())
+	}
+}
+
+#[cfg(feature = "std")]
+impl client::runtime_api::TaggedTransactionQueue<GBlock> for ClientWithApi {
+	fn validate_transaction(
+		&self,
+		at: &GBlockId,
+		utx: &<GBlock as BlockT>::Extrinsic
+	) -> Result<TransactionValidity, client::error::Error> {
+		self.call_api_at(at, "validate_transaction", utx)
+	}
+}
+
+#[cfg(feature = "std")]
+impl client::runtime_api::Metadata<GBlock> for ClientWithApi {
+	fn metadata(&self, at: &GBlockId) -> Result<OpaqueMetadata, client::error::Error> {
+		self.call_api_at(at, "metadata", &())
+	}
+}
+
+impl_runtime_apis! {
+	impl Core<Block> for Runtime {
 		fn version() -> RuntimeVersion {
 			VERSION
 		}
@@ -249,19 +408,19 @@ impl_apis! {
 		fn execute_block(block: Block) {
 			Executive::execute_block(block)
 		}
+
+		fn initialise_block(header: <Block as BlockT>::Header) {
+			Executive::initialise_block(&header)
+		}
 	}
 
-	impl Metadata<RuntimeMetadata> for Runtime {
-		fn metadata() -> RuntimeMetadata {
-			Runtime::metadata()
+	impl Metadata for Runtime {
+		fn metadata() -> OpaqueMetadata {
+			Runtime::metadata().into()
 		}
 	}
 
 	impl BlockBuilder<Block, InherentData, UncheckedExtrinsic, InherentData, InherentError> for Runtime {
-		fn initialise_block(header: <Block as BlockT>::Header) {
-			Executive::initialise_block(&header)
-		}
-
 		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyResult {
 			Executive::apply_extrinsic(extrinsic)
 		}
@@ -283,7 +442,7 @@ impl_apis! {
 		}
 	}
 
-	impl TaggedTransactionQueue<Block, TransactionValidity> for Runtime {
+	impl TaggedTransactionQueue<Block> for Runtime {
 		fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity {
 			Executive::validate_transaction(tx)
 		}

substrate/node/runtime/wasm/Cargo.toml

@@ -8,11 +8,11 @@ crate-type = ["cdylib"]
 
 [dependencies]
 integer-sqrt = { version = "0.1.2" }
-safe-mix = { version = "1.0", default-features = false}
+safe-mix = { version = "1.0", default-features = false }
 parity-codec-derive = { version = "2.1" }
 parity-codec = { version = "2.1", default-features = false }
 substrate-primitives = { path = "../../../core/primitives", default-features = false }
-sr-api = { path = "../../../core/sr-api", default-features = false }
+substrate-client = { path = "../../../core/client", default-features = false }
 sr-std = { path = "../../../core/sr-std", default-features = false }
 srml-support = { path = "../../../srml/support", default-features = false }
 srml-balances = { path = "../../../srml/balances", default-features = false }
@@ -37,7 +37,7 @@ std = [
 	"safe-mix/std",
 	"parity-codec/std",
 	"substrate-primitives/std",
-	"sr-api/std",
+	"substrate-client/std",
 	"sr-std/std",
 	"srml-support/std",
 	"srml-balances/std",