add system_dryRun

bin/node/rpc/Cargo.toml

@@ -31,3 +31,4 @@ sp-blockchain = { version = "2.0.0-rc3", path = "../../../primitives/blockchain"
 sc-finality-grandpa = { version = "0.8.0-rc3", path = "../../../client/finality-grandpa" }
 sc-finality-grandpa-rpc = { version = "0.8.0-rc3", path = "../../../client/finality-grandpa/rpc" }
 sc-rpc-api = { version = "0.8.0-rc3", path = "../../../client/rpc-api" }
+sp-block-builder = { version = "2.0.0-rc3", path = "../../../primitives/block-builder" }

bin/node/rpc/src/lib.rs

@@ -30,7 +30,7 @@
 
 #![warn(missing_docs)]
 
-use std::{sync::Arc, fmt};
+use std::sync::Arc;
 
 use node_primitives::{Block, BlockNumber, AccountId, Index, Balance, Hash};
 use node_runtime::UncheckedExtrinsic;
@@ -46,6 +46,7 @@ use sc_consensus_babe_rpc::BabeRpcHandler;
 use sc_finality_grandpa::{SharedVoterState, SharedAuthoritySet};
 use sc_finality_grandpa_rpc::GrandpaRpcHandler;
 use sc_rpc_api::DenyUnsafe;
+use sp_block_builder::BlockBuilder;
 
 /// Light client extra dependencies.
 pub struct LightDeps<C, F, P> {
@@ -104,7 +105,7 @@ pub fn create_full<C, P, M, SC>(
 	C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber>,
 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance, UncheckedExtrinsic>,
 	C::Api: BabeApi<Block>,
-	<C::Api as sp_api::ApiErrorExt>::Error: fmt::Debug,
+	C::Api: BlockBuilder<Block>,
 	P: TransactionPool + 'static,
 	M: jsonrpc_core::Metadata + Default,
 	SC: SelectChain<Block> +'static,
@@ -133,7 +134,7 @@ pub fn create_full<C, P, M, SC>(
 	} = grandpa;
 
 	io.extend_with(
-		SystemApi::to_delegate(FullSystem::new(client.clone(), pool))
+		SystemApi::to_delegate(FullSystem::new(client.clone(), pool, deny_unsafe))
 	);
 	// Making synchronous calls in light client freezes the browser currently,
 	// more context: https://github.com/paritytech/substrate/pull/3480
@@ -185,7 +186,7 @@ pub fn create_light<C, P, M, F>(
 	} = deps;
 	let mut io = jsonrpc_core::IoHandler::default();
 	io.extend_with(
-		SystemApi::<AccountId, Index>::to_delegate(LightSystem::new(client, remote_blockchain, fetcher, pool))
+		SystemApi::<Hash, AccountId, Index>::to_delegate(LightSystem::new(client, remote_blockchain, fetcher, pool))
 	);
 
 	io

client/consensus/babe/rpc/src/lib.rs

@@ -38,7 +38,7 @@ use sp_api::{ProvideRuntimeApi, BlockId};
 use sp_runtime::traits::{Block as BlockT, Header as _};
 use sp_consensus::{SelectChain, Error as ConsensusError};
 use sp_blockchain::{HeaderBackend, HeaderMetadata, Error as BlockChainError};
-use std::{collections::HashMap, fmt, sync::Arc};
+use std::{collections::HashMap, sync::Arc};
 
 type FutureResult<T> = Box<dyn rpc_future::Future<Item = T, Error = RpcError> + Send>;
 
@@ -93,7 +93,6 @@ impl<B, C, SC> BabeApi for BabeRpcHandler<B, C, SC>
 		B: BlockT,
 		C: ProvideRuntimeApi<B> + HeaderBackend<B> + HeaderMetadata<B, Error=BlockChainError> + 'static,
 		C::Api: BabeRuntimeApi<B>,
-		<C::Api as sp_api::ApiErrorExt>::Error: fmt::Debug,
 		SC: SelectChain<B> + Clone + 'static,
 {
 	fn epoch_authorship(&self) -> FutureResult<HashMap<AuthorityId, EpochAuthorship>> {

utils/frame/rpc/system/Cargo.toml

@@ -26,6 +26,8 @@ frame-system-rpc-runtime-api = { version = "2.0.0-rc3", path = "../../../../fram
 sp-core = { version = "2.0.0-rc3", path = "../../../../primitives/core" }
 sp-blockchain = { version = "2.0.0-rc3", path = "../../../../primitives/blockchain" }
 sp-transaction-pool = { version = "2.0.0-rc3", path = "../../../../primitives/transaction-pool" }
+sp-block-builder = { version = "2.0.0-rc3", path = "../../../../primitives/block-builder" }
+sc-rpc-api = { version = "0.8.0-rc3", path = "../../../../client/rpc-api" }
 
 [dev-dependencies]
 substrate-test-runtime-client = { version = "2.0.0-rc3", path = "../../../../test-utils/runtime/client" }

utils/frame/rpc/system/src/lib.rs

@@ -22,8 +22,8 @@ use std::sync::Arc;
 use codec::{self, Codec, Decode, Encode};
 use sc_client_api::light::{future_header, RemoteBlockchain, Fetcher, RemoteCallRequest};
 use jsonrpc_core::{
-	Error, ErrorCode,
-	futures::future::{result, Future},
+	Error as RpcError, ErrorCode,
+	futures::future::{self as rpc_future,result, Future},
 };
 use jsonrpc_derive::rpc;
 use futures::future::{ready, TryFutureExt};
@@ -35,53 +35,78 @@ use sp_runtime::{
 	generic::BlockId,
 	traits,
 };
-use sp_core::hexdisplay::HexDisplay;
+use sp_core::{hexdisplay::HexDisplay, Bytes};
 use sp_transaction_pool::{TransactionPool, InPoolTransaction};
+use sp_block_builder::BlockBuilder;
+use sc_rpc_api::DenyUnsafe;
 
 pub use frame_system_rpc_runtime_api::AccountNonceApi;
 pub use self::gen_client::Client as SystemClient;
 
 /// Future that resolves to account nonce.
-pub type FutureResult<T> = Box<dyn Future<Item = T, Error = Error> + Send>;
+pub type FutureResult<T> = Box<dyn Future<Item = T, Error = RpcError> + Send>;
 
 /// System RPC methods.
 #[rpc]
-pub trait SystemApi<AccountId, Index> {
+pub trait SystemApi<BlockHash, AccountId, Index> {
 	/// Returns the next valid index (aka nonce) for given account.
 	///
 	/// This method takes into consideration all pending transactions
 	/// currently in the pool and if no transactions are found in the pool
 	/// it fallbacks to query the index from the runtime (aka. state nonce).
 	#[rpc(name = "system_accountNextIndex", alias("account_nextIndex"))]
 	fn nonce(&self, account: AccountId) -> FutureResult<Index>;
+
+	/// Dry run an extrinsic at a given block. Return all encoded events emitted during execution.
+	#[rpc(name = "system_dryRun", alias("system_dryRunAt"))]
+	fn dry_run(&self, extrinsic: Bytes, at: Option<BlockHash>) -> FutureResult<Bytes>;
+}
+
+/// Error type of this RPC api.
+pub enum Error {
+	/// The transaction was not decodable.
+	DecodeError,
+	/// The call to runtime failed.
+	RuntimeError,
 }
 
-const RUNTIME_ERROR: i64 = 1;
+impl From<Error> for i64 {
+	fn from(e: Error) -> i64 {
+		match e {
+			Error::RuntimeError => 1,
+			Error::DecodeError => 2,
+		}
+	}
+}
 
 /// An implementation of System-specific RPC methods on full client.
 pub struct FullSystem<P: TransactionPool, C, B> {
 	client: Arc<C>,
 	pool: Arc<P>,
+	deny_unsafe: DenyUnsafe,
 	_marker: std::marker::PhantomData<B>,
 }
 
 impl<P: TransactionPool, C, B> FullSystem<P, C, B> {
 	/// Create new `FullSystem` given client and transaction pool.
-	pub fn new(client: Arc<C>, pool: Arc<P>) -> Self {
+	pub fn new(client: Arc<C>, pool: Arc<P>, deny_unsafe: DenyUnsafe,) -> Self {
 		FullSystem {
 			client,
 			pool,
+			deny_unsafe,
 			_marker: Default::default(),
 		}
 	}
 }
 
-impl<P, C, Block, AccountId, Index> SystemApi<AccountId, Index> for FullSystem<P, C, Block>
+impl<P, C, Block, AccountId, Index> SystemApi<<Block as traits::Block>::Hash, AccountId, Index>
+	for FullSystem<P, C, Block>
 where
 	C: sp_api::ProvideRuntimeApi<Block>,
 	C: HeaderBackend<Block>,
 	C: Send + Sync + 'static,
 	C::Api: AccountNonceApi<Block, AccountId, Index>,
+	C::Api: BlockBuilder<Block>,
 	P: TransactionPool + 'static,
 	Block: traits::Block,
 	AccountId: Clone + std::fmt::Display + Codec,
@@ -93,8 +118,8 @@ where
 			let best = self.client.info().best_hash;
 			let at = BlockId::hash(best);
 
-			let nonce = api.account_nonce(&at, account.clone()).map_err(|e| Error {
-				code: ErrorCode::ServerError(RUNTIME_ERROR),
+			let nonce = api.account_nonce(&at, account.clone()).map_err(|e| RpcError {
+				code: ErrorCode::ServerError(Error::RuntimeError.into()),
 				message: "Unable to query nonce.".into(),
 				data: Some(format!("{:?}", e).into()),
 			})?;
@@ -104,6 +129,38 @@ where
 
 		Box::new(result(get_nonce()))
 	}
+
+	fn dry_run(&self, extrinsic: Bytes, at: Option<<Block as traits::Block>::Hash>) -> FutureResult<Bytes> {
+		if let Err(err) = self.deny_unsafe.check_if_safe() {
+			return Box::new(rpc_future::err(err.into()));
+		}
+
+		let dry_run = || {
+			let api = self.client.runtime_api();
+			let at = BlockId::<Block>::hash(at.unwrap_or_else(||
+				// If the block hash is not supplied assume the best block.
+				self.client.info().best_hash
+			));
+
+			let uxt: <Block as traits::Block>::Extrinsic = Decode::decode(&mut &*extrinsic).map_err(|e| RpcError {
+				code: ErrorCode::ServerError(Error::DecodeError.into()),
+				message: "Unable to dry run extrinsic.".into(),
+				data: Some(format!("{:?}", e).into()),
+			})?;
+
+			let result = api.apply_extrinsic(&at, uxt)
+				.map_err(|e| RpcError {
+					code: ErrorCode::ServerError(Error::RuntimeError.into()),
+					message: "Unable to dry run extrinsic.".into(),
+					data: Some(format!("{:?}", e).into()),
+				})?;
+
+			Ok(Encode::encode(&result).into())
+		};
+
+
+		Box::new(result(dry_run()))
+	}
 }
 
 /// An implementation of System-specific RPC methods on light client.
@@ -131,7 +188,8 @@ impl<P: TransactionPool, C, F, Block> LightSystem<P, C, F, Block> {
 	}
 }
 
-impl<P, C, F, Block, AccountId, Index> SystemApi<AccountId, Index> for LightSystem<P, C, F, Block>
+impl<P, C, F, Block, AccountId, Index> SystemApi<<Block as traits::Block>::Hash, AccountId, Index>
+	for LightSystem<P, C, F, Block>
 where
 	P: TransactionPool + 'static,
 	C: HeaderBackend<Block>,
@@ -165,8 +223,8 @@ where
 		).compat();
 		let future_nonce = future_nonce.and_then(|nonce| Decode::decode(&mut &nonce[..])
 			.map_err(|e| ClientError::CallResultDecode("Cannot decode account nonce", e)));
-		let future_nonce = future_nonce.map_err(|e| Error {
-			code: ErrorCode::ServerError(RUNTIME_ERROR),
+		let future_nonce = future_nonce.map_err(|e| RpcError {
+			code: ErrorCode::ServerError(Error::RuntimeError.into()),
 			message: "Unable to query nonce.".into(),
 			data: Some(format!("{:?}", e).into()),
 		});
@@ -176,6 +234,14 @@ where
 
 		Box::new(future_nonce)
 	}
+
+	fn dry_run(&self, _extrinsic: Bytes, _at: Option<<Block as traits::Block>::Hash>) -> FutureResult<Bytes> {
+		Box::new(result(Err(RpcError {
+			code: ErrorCode::MethodNotFound,
+			message: "Unable to dry run extrinsic.".into(),
+			data: None,
+		})))
+	}
 }
 
 /// Adjust account nonce from state, so that tx with the nonce will be
@@ -224,6 +290,7 @@ mod tests {
 	use futures::executor::block_on;
 	use substrate_test_runtime_client::{runtime::Transfer, AccountKeyring};
 	use sc_transaction_pool::{BasicPool, FullChainApi};
+	use sp_runtime::{ApplyExtrinsicResult, transaction_validity::{TransactionValidityError, InvalidTransaction}};
 
 	#[test]
 	fn should_return_next_nonce_for_some_account() {
@@ -255,12 +322,99 @@ mod tests {
 		let ext1 = new_transaction(1);
 		block_on(pool.submit_one(&BlockId::number(0), source, ext1)).unwrap();
 
-		let accounts = FullSystem::new(client, pool);
+		let accounts = FullSystem::new(client, pool, DenyUnsafe::Yes);
 
 		// when
 		let nonce = accounts.nonce(AccountKeyring::Alice.into());
 
 		// then
 		assert_eq!(nonce.wait().unwrap(), 2);
 	}
+
+	#[test]
+	fn dry_run_should_deny_unsafe() {
+		let _ = env_logger::try_init();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let pool = Arc::new(
+			BasicPool::new(
+				Default::default(),
+				Arc::new(FullChainApi::new(client.clone())),
+				None,
+			).0
+		);
+
+		let accounts = FullSystem::new(client, pool, DenyUnsafe::Yes);
+
+		// when
+		let res = accounts.dry_run(vec![].into(), None);
+
+		// then
+		assert_eq!(res.wait(), Err(RpcError::method_not_found()));
+	}
+
+	#[test]
+	fn dry_run_should_work() {
+		let _ = env_logger::try_init();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let pool = Arc::new(
+			BasicPool::new(
+				Default::default(),
+				Arc::new(FullChainApi::new(client.clone())),
+				None,
+			).0
+		);
+
+		let accounts = FullSystem::new(client, pool, DenyUnsafe::No);
+
+		let tx = Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Bob.into(),
+			amount: 5,
+			nonce: 0,
+		}.into_signed_tx();
+
+		// when
+		let res = accounts.dry_run(tx.encode().into(), None);
+
+		// then
+		let bytes = res.wait().unwrap().0;
+		let apply_res: ApplyExtrinsicResult = Decode::decode(&mut bytes.as_slice()).unwrap();
+		assert_eq!(apply_res, Ok(Ok(())));
+	}
+
+	#[test]
+	fn dry_run_should_indicate_error() {
+		let _ = env_logger::try_init();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let pool = Arc::new(
+			BasicPool::new(
+				Default::default(),
+				Arc::new(FullChainApi::new(client.clone())),
+				None,
+			).0
+		);
+
+		let accounts = FullSystem::new(client, pool, DenyUnsafe::No);
+
+		let tx = Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Bob.into(),
+			amount: 5,
+			nonce: 100,
+		}.into_signed_tx();
+
+		// when
+		let res = accounts.dry_run(tx.encode().into(), None);
+
+		// then
+		let bytes = res.wait().unwrap().0;
+		let apply_res: ApplyExtrinsicResult = Decode::decode(&mut bytes.as_slice()).unwrap();
+		assert_eq!(apply_res, Err(TransactionValidityError::Invalid(InvalidTransaction::Stale)));
+	}
 }