Rewrite impl_runtime_apis! and decl_runtime_apis! as proc-macro

Cargo.toml

@@ -60,7 +60,7 @@ members = [
 	"core/serializer",
 	"core/service",
 	"core/service/test",
-	"core/state-db",
+	"core/sr-api-macros",
 	"core/state-machine",
 	"core/test-runtime",
 	"core/telemetry",

core/client/Cargo.toml

@@ -26,6 +26,7 @@ substrate-primitives = { path = "../primitives", default-features = false }
 sr-primitives = { path = "../sr-primitives", default-features = false }
 sr-version = { path = "../sr-version", default-features = false }
 sr-std = { path = "../sr-std", default-features = false }
+sr-api-macros = { path = "../sr-api-macros" }
 
 [dev-dependencies]
 substrate-test-client = { path = "../test-client" }

core/client/src/block_builder/api.rs

@@ -16,24 +16,20 @@
 
 //! The runtime api for building blocks.
 
-use runtime_primitives::{traits::Block as BlockT, ApplyResult};
+use runtime_primitives::{traits::Block as BlockT, ApplyResult, InherentData, CheckInherentError};
 use rstd::vec::Vec;
 
 decl_runtime_apis! {
 	/// The `BlockBuilder` api trait that provides required functions for building a block for a runtime.
-	pub trait BlockBuilder<Block: BlockT> {
+	pub trait BlockBuilder {
 		/// Apply the given extrinsics.
 		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyResult;
 		/// Finish the current block.
 		fn finalise_block() -> <Block as BlockT>::Header;
 		/// Generate inherent extrinsics.
-		fn inherent_extrinsics<InherentExtrinsic, UncheckedExtrinsic>(
-			inherent: InherentExtrinsic
-		) -> Vec<UncheckedExtrinsic>;
+		fn inherent_extrinsics(inherent: InherentData) -> Vec<<Block as BlockT>::Extrinsic>;
 		/// Check that the inherents are valid.
-		fn check_inherents<InherentData, Error>(
-			block: Block, data: InherentData
-		) -> Result<(), Error>;
+		fn check_inherents(block: Block, data: InherentData) -> Result<(), CheckInherentError>;
 		/// Generate a random seed.
 		fn random_seed() -> <Block as BlockT>::Hash;
 	}

core/client/src/client.rs

@@ -1221,14 +1221,14 @@ pub(crate) mod tests {
 	use consensus::BlockOrigin;
 	use test_client::client::backend::Backend as TestBackend;
 	use test_client::BlockBuilderExt;
-	use test_client::runtime::{self, Block, Transfer, ClientWithApi, test_api::TestAPI};
+	use test_client::runtime::{self, Block, Transfer, RuntimeApi, test_api::TestAPI};
 
 	/// Returns tuple, consisting of:
 	/// 1) test client pre-filled with blocks changing balances;
 	/// 2) roots of changes tries for these blocks
 	/// 3) test cases in form (begin, end, key, vec![(block, extrinsic)]) that are required to pass
 	pub fn prepare_client_with_key_changes() -> (
-		test_client::client::Client<test_client::Backend, test_client::Executor, Block, ClientWithApi>,
+		test_client::client::Client<test_client::Backend, test_client::Executor, Block, RuntimeApi>,
 		Vec<H256>,
 		Vec<(u64, u64, Vec<u8>, Vec<(u64, u32)>)>,
 	) {
@@ -1303,14 +1303,14 @@ pub(crate) mod tests {
 		assert_eq!(
 			client.runtime_api().balance_of(
 				&BlockId::Number(client.info().unwrap().chain.best_number),
-				&Keyring::Alice.to_raw_public()
+				&Keyring::Alice.to_raw_public().into()
 			).unwrap(),
 			1000
 		);
 		assert_eq!(
 			client.runtime_api().balance_of(
 				&BlockId::Number(client.info().unwrap().chain.best_number),
-				&Keyring::Ferdie.to_raw_public()
+				&Keyring::Ferdie.to_raw_public().into()
 			).unwrap(),
 			0
 		);
@@ -1359,14 +1359,14 @@ pub(crate) mod tests {
 		assert_eq!(
 			client.runtime_api().balance_of(
 				&BlockId::Number(client.info().unwrap().chain.best_number),
-				&Keyring::Alice.to_raw_public()
+				&Keyring::Alice.to_raw_public().into()
 			).unwrap(),
 			958
 		);
 		assert_eq!(
 			client.runtime_api().balance_of(
 				&BlockId::Number(client.info().unwrap().chain.best_number),
-				&Keyring::Ferdie.to_raw_public()
+				&Keyring::Ferdie.to_raw_public().into()
 			).unwrap(),
 			42
 		);

core/client/src/lib.rs

@@ -31,6 +31,8 @@ extern crate substrate_state_machine as state_machine;
 extern crate substrate_consensus_common as consensus;
 extern crate sr_version as runtime_version;
 extern crate sr_std as rstd;
+#[macro_use]
+extern crate sr_api_macros;
 #[cfg(test)]
 extern crate substrate_keyring as keyring;
 #[cfg(test)]
@@ -114,3 +116,6 @@ pub use notifications::{StorageEventStream, StorageChangeSet};
 pub use state_machine::ExecutionStrategy;
 #[cfg(feature = "std")]
 pub use leaves::LeafSet;
+
+#[doc(inline)]
+pub use sr_api_macros::{decl_runtime_apis, impl_runtime_apis};

core/client/src/runtime_api/mod.rs → core/client/src/runtime_api.rs

@@ -14,30 +14,27 @@
 // You should have received a copy of the GNU General Public License
 // along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
 
-//! All the functionality required for declaring and implementing runtime api's.
-//! Core api's are also declared here.
+//! All the functionality required for declaring and implementing runtime apis.
 
 #[doc(hidden)]
 #[cfg(feature = "std")]
 pub use state_machine::OverlayedChanges;
 #[doc(hidden)]
-pub use runtime_primitives::{traits::Block as BlockT, generic::BlockId};
-#[cfg(feature = "std")]
-use runtime_primitives::traits::ApiRef;
-pub use runtime_version::ApiId;
+pub use runtime_primitives::{
+	traits::{Block as BlockT, GetNodeBlockType, GetRuntimeBlockType, ApiRef}, generic::BlockId,
+	transaction_validity::TransactionValidity
+};
+pub use runtime_version::{ApiId, RuntimeVersion};
 #[doc(hidden)]
 pub use rstd::slice;
 #[cfg(feature = "std")]
 use rstd::result;
 pub use codec::{Encode, Decode};
 #[cfg(feature = "std")]
 use error;
-pub use runtime_version::RuntimeVersion;
+use rstd::vec::Vec;
+use primitives::{AuthorityId, OpaqueMetadata};
 
-mod core;
-#[macro_use]
-mod macros;
-mod traits;
 
 /// Something that can be constructed to a runtime api.
 #[cfg(feature = "std")]
@@ -113,11 +110,29 @@ pub mod id {
 	pub const METADATA: ApiId = *b"metadata";
 }
 
-pub use self::core::*;
-pub use self::traits::*;
+decl_runtime_apis! {
+	/// The `Core` api trait that is mandantory for each runtime.
+	#[core_trait]
+	pub trait Core {
+		/// Returns the version of the runtime.
+		fn version() -> RuntimeVersion;
+		/// Returns the authorities.
+		fn authorities() -> Vec<AuthorityId>;
+		/// Execute the given block.
+		fn execute_block(block: Block);
+		/// Initialise a block with the given header.
+		fn initialise_block(header: <Block as BlockT>::Header);
+	}
 
-/// The runtime apis that should be implemented for the `Runtime`.
-pub mod runtime {
-	pub use super::core::runtime::Core;
-	pub use super::traits::runtime::*;
+	/// The `Metadata` api trait that returns metadata for the runtime.
+	pub trait Metadata {
+		/// Returns the metadata of a runtime.
+		fn metadata() -> OpaqueMetadata;
+	}
+
+	/// The `TaggedTransactionQueue` api trait for interfering with the new transaction queue.
+	pub trait TaggedTransactionQueue {
+		/// Validate the given transaction.
+		fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity;
+	}
 }