Add an RPC method for calling a contract. (#3563)

* Sketch

* Some work on docs.

* Doc improvements.

* More docs.

* Some more docs.

* Yet another comment.

* Bump impl_version.

* Accept the block hash

* Use NumberOrHex

* Update node/rpc/src/contracts.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* Move rpc/primitives

substrate/Cargo.lock

@@ -2429,6 +2429,7 @@ dependencies = [
  "substrate-client 2.0.0",
  "substrate-keyring 2.0.0",
  "substrate-primitives 2.0.0",
+ "substrate-rpc-primitives 2.0.0",
  "substrate-transaction-pool 2.0.0",
 ]
 
@@ -5164,6 +5165,7 @@ dependencies = [
  "substrate-network 2.0.0",
  "substrate-primitives 2.0.0",
  "substrate-rpc-api 2.0.0",
+ "substrate-rpc-primitives 2.0.0",
  "substrate-session 2.0.0",
  "substrate-state-machine 2.0.0",
  "substrate-test-runtime-client 2.0.0",
@@ -5188,9 +5190,18 @@ dependencies = [
  "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)",
  "sr-version 2.0.0",
  "substrate-primitives 2.0.0",
+ "substrate-rpc-primitives 2.0.0",
  "substrate-transaction-graph 2.0.0",
 ]
 
+[[package]]
+name = "substrate-rpc-primitives"
+version = "2.0.0"
+dependencies = [
+ "serde 1.0.97 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-primitives 2.0.0",
+]
+
 [[package]]
 name = "substrate-rpc-servers"
 version = "2.0.0"

substrate/Cargo.toml

@@ -42,6 +42,7 @@ members = [
 	"core/panic-handler",
 	"core/primitives",
 	"core/rpc",
+	"core/rpc/primitives",
 	"core/rpc-servers",
 	"core/serializer",
 	"core/service",

substrate/core/rpc/Cargo.toml

@@ -17,6 +17,7 @@ runtime_version = { package = "sr-version", path = "../sr-version" }
 serde_json = "1.0"
 session = { package = "substrate-session", path = "../session" }
 sr-primitives = { path = "../sr-primitives" }
+rpc-primitives = { package = "substrate-rpc-primitives", path = "primitives" }
 state_machine = { package = "substrate-state-machine", path = "../state-machine" }
 substrate-executor = { path = "../executor" }
 substrate-keystore = { path = "../keystore" }

substrate/core/rpc/api/Cargo.toml

@@ -19,3 +19,4 @@ runtime_version = { package = "sr-version", path = "../../sr-version" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 txpool = { package = "substrate-transaction-graph", path = "../../transaction-pool/graph" }
+rpc-primitives = { package = "substrate-rpc-primitives", path = "../../rpc/primitives" }

substrate/core/rpc/api/src/chain/mod.rs

@@ -17,12 +17,12 @@
 //! Substrate blockchain API.
 
 pub mod error;
-pub mod number;
 
 use jsonrpc_core::Result as RpcResult;
 use jsonrpc_core::futures::Future;
 use jsonrpc_derive::rpc;
 use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
+use rpc_primitives::number;
 use self::error::{FutureResult, Result};
 
 pub use self::gen_client::Client as ChainClient;

substrate/core/rpc/primitives/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "substrate-rpc-primitives"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2018"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+primitives = { package = "substrate-primitives", path = "../../primitives" }

substrate/core/rpc/primitives/src/lib.rs

@@ -0,0 +1,21 @@
+// Copyright 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 RPC primitives and utilities.
+
+#![warn(missing_docs)]
+
+pub mod number;

substrate/core/rpc/src/chain/mod.rs

@@ -37,6 +37,7 @@ use client::{
 };
 use jsonrpc_pubsub::{typed::Subscriber, SubscriptionId};
 use primitives::{H256, Blake2Hasher};
+use rpc_primitives::number;
 use sr_primitives::{
 	generic::{BlockId, SignedBlock},
 	traits::{Block as BlockT, Header, NumberFor},

substrate/node/cli/src/service.rs

@@ -270,11 +270,17 @@ pub fn new_light<C: Send + Default + 'static>(config: Configuration<C, GenesisCo
 			Ok(Arc::new(GrandpaFinalityProofProvider::new(backend, client)) as _)
 		)?
 		.with_rpc_extensions(|client, pool| {
-			use node_rpc::accounts::{Accounts, AccountsApi};
+			use node_rpc::{
+				accounts::{Accounts, AccountsApi},
+				contracts::{Contracts, ContractsApi},
+			};
 
 			let mut io = jsonrpc_core::IoHandler::default();
 			io.extend_with(
-				AccountsApi::to_delegate(Accounts::new(client, pool))
+				AccountsApi::to_delegate(Accounts::new(client.clone(), pool))
+			);
+			io.extend_with(
+				ContractsApi::to_delegate(Contracts::new(client))
 			);
 			io
 		})?

substrate/node/primitives/src/lib.rs

@@ -20,10 +20,15 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use rstd::prelude::*;
 use sr_primitives::{
 	generic, traits::{Verify, BlakeTwo256}, OpaqueExtrinsic, AnySignature
 };
 
+#[cfg(feature = "std")]
+use serde::{Serialize, Deserialize};
+use codec::{Encode, Decode};
+
 /// An index to a block.
 pub type BlockNumber = u32;
 
@@ -67,10 +72,43 @@ pub type BlockId = generic::BlockId<Block>;
 /// Opaque, encoded, unchecked extrinsic.
 pub type UncheckedExtrinsic = OpaqueExtrinsic;
 
+/// A result of execution of a contract.
+#[derive(Eq, PartialEq, Encode, Decode)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+pub enum ContractExecResult {
+	/// The contract returned successfully.
+	///
+	/// There is a status code and, optionally, some data returned by the contract.
+	Success {
+		/// Status code returned by the contract.
+		status: u8,
+		/// Output data returned by the contract.
+		///
+		/// Can be empty.
+		data: Vec<u8>,
+	},
+	/// The contract execution either trapped or returned an error.
+	Error,
+}
+
 client::decl_runtime_apis! {
 	/// The API to query account account nonce (aka index).
 	pub trait AccountNonceApi {
 		/// Get current account nonce of given `AccountId`.
 		fn account_nonce(account: AccountId) -> Index;
 	}
+
+	/// The API to interact with contracts without using executive.
+	pub trait ContractsApi {
+		/// Perform a call from a specified account to a given contract.
+		///
+		/// See the contracts' `call` dispatchable function for more details.
+		fn call(
+			origin: AccountId,
+			dest: AccountId,
+			value: Balance,
+			gas_limit: u64,
+			input_data: Vec<u8>,
+		) -> ContractExecResult;
+	}
 }

substrate/node/rpc/Cargo.toml

@@ -17,6 +17,7 @@ codec = { package = "parity-scale-codec", version = "1.0.0" }
 serde = { version = "1.0", features = ["derive"] }
 sr-primitives = { path = "../../core/sr-primitives" }
 substrate-primitives = { path = "../../core/primitives" }
+rpc-primitives = { package = "substrate-rpc-primitives", path = "../../core/rpc/primitives" }
 transaction_pool = { package = "substrate-transaction-pool", path = "../../core/transaction-pool" }
 
 [dev-dependencies]

substrate/node/rpc/src/accounts.rs

@@ -31,8 +31,6 @@ use transaction_pool::txpool::{self, Pool};
 
 pub use self::gen_client::Client as AccountsClient;
 
-const RUNTIME_ERROR: i64 = 1;
-
 /// Accounts RPC methods.
 #[rpc]
 pub trait AccountsApi {
@@ -75,7 +73,7 @@ where
 		let at = BlockId::hash(best);
 
 		let nonce = api.account_nonce(&at, account.clone()).map_err(|e| Error {
-			code: ErrorCode::ServerError(RUNTIME_ERROR),
+			code: ErrorCode::ServerError(crate::constants::RUNTIME_ERROR),
 			message: "Unable to query nonce.".into(),
 			data: Some(format!("{:?}", e).into()),
 		})?;

substrate/node/rpc/src/contracts.rs

@@ -0,0 +1,116 @@
+// Copyright 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/>.
+
+//! Node-specific RPC methods for interaction with contracts.
+
+use std::sync::Arc;
+
+use serde::{Serialize, Deserialize};
+use client::blockchain::HeaderBackend;
+use jsonrpc_core::{Error, ErrorCode, Result};
+use jsonrpc_derive::rpc;
+use node_primitives::{
+	AccountId, Balance, Block, BlockId, ContractExecResult, ContractsApi as ContractsRuntimeApi,
+};
+use sr_primitives::traits::{
+	self,
+	Block as BlockT,
+};
+use rpc_primitives::number;
+
+/// A struct that encodes RPC parameters required for a call to a smart-contract.
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all="camelCase")]
+#[serde(deny_unknown_fields)]
+pub struct CallRequest {
+	origin: AccountId,
+	dest: AccountId,
+	value: Balance,
+	gas_limit: number::NumberOrHex<u64>,
+	input_data: Vec<u8>,
+}
+
+/// Contracts RPC methods.
+#[rpc]
+pub trait ContractsApi<BlockHash> {
+	/// Executes a call to a contract.
+	///
+	/// This call is performed locally without submitting any transactions. Thus executing this
+	/// won't change any state. Nonetheless, the calling state-changing contracts is still possible.
+	///
+	/// This method is useful for calling getter-like methods on contracts.
+	#[rpc(name = "contracts_call")]
+	fn call(
+		&self,
+		call_request: CallRequest,
+		at: Option<BlockHash>,
+	) -> Result<ContractExecResult>;
+}
+
+/// An implementation of contract specific RPC methods.
+pub struct Contracts<C> {
+	client: Arc<C>,
+}
+
+impl<C> Contracts<C> {
+	/// Create new `Contracts` with the given reference to the client.
+	pub fn new(client: Arc<C>) -> Self {
+		Contracts { client }
+	}
+}
+
+impl<C> ContractsApi<<Block as BlockT>::Hash> for Contracts<C>
+where
+	C: Send + Sync + 'static,
+	C: traits::ProvideRuntimeApi,
+	C: HeaderBackend<Block>,
+	C::Api: ContractsRuntimeApi<Block>,
+{
+	fn call(
+		&self,
+		call_request: CallRequest,
+		at: Option<<Block as BlockT>::Hash>,
+	) -> Result<ContractExecResult> {
+		let api = self.client.runtime_api();
+		let at = BlockId::hash(at.unwrap_or_else(||
+			// If the block hash is not supplied assume the best block.
+			self.client.info().best_hash
+		));
+
+		let CallRequest {
+			origin,
+			dest,
+			value,
+			gas_limit,
+			input_data
+		} = call_request;
+		let gas_limit = gas_limit.to_number().map_err(|e| Error {
+			code: ErrorCode::InvalidParams,
+			message: e,
+			data: None,
+		})?;
+
+		let exec_result = api
+			.call(&at, origin, dest, value, gas_limit, input_data)
+			.map_err(|e| Error {
+				code: ErrorCode::ServerError(crate::constants::RUNTIME_ERROR),
+				message: "Runtime trapped while executing a contract.".into(),
+				data: Some(format!("{:?}", e).into()),
+			})?;
+
+		Ok(exec_result)
+	}
+}

substrate/node/rpc/src/lib.rs

@@ -30,3 +30,11 @@
 #![warn(missing_docs)]
 
 pub mod accounts;
+pub mod contracts;
+
+mod constants {
+	/// A status code indicating an error happened while trying to call into the runtime.
+	///
+	/// This typically means that the runtime trapped.
+	pub const RUNTIME_ERROR: i64 = 1;
+}

substrate/node/runtime/src/lib.rs

@@ -27,7 +27,7 @@ use support::{
 use primitives::u32_trait::{_1, _2, _3, _4};
 use node_primitives::{
 	AccountId, AccountIndex, Balance, BlockNumber, Hash, Index,
-	Moment, Signature,
+	Moment, Signature, ContractExecResult,
 };
 use babe::{AuthorityId as BabeId};
 use grandpa::fg_primitives::{self, ScheduledChange};
@@ -83,7 +83,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
 	spec_version: 156,
-	impl_version: 157,
+	impl_version: 158,
 	apis: RUNTIME_API_VERSIONS,
 };
 
@@ -654,6 +654,31 @@ impl_runtime_apis! {
 		}
 	}
 
+	impl node_primitives::ContractsApi<Block> for Runtime {
+		fn call(
+			origin: AccountId,
+			dest: AccountId,
+			value: Balance,
+			gas_limit: u64,
+			input_data: Vec<u8>,
+		) -> ContractExecResult {
+			let exec_result = Contracts::bare_call(
+				origin,
+				dest.into(),
+				value,
+				gas_limit,
+				input_data,
+			);
+			match exec_result {
+				Ok(v) => ContractExecResult::Success {
+					status: v.status,
+					data: v.data,
+				},
+				Err(_) => ContractExecResult::Error,
+			}
+		}
+	}
+
 	impl substrate_session::SessionKeys<Block> for Runtime {
 		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
 			let seed = seed.as_ref().map(|s| rstd::str::from_utf8(&s).expect("Seed is an utf8 string"));

substrate/srml/contracts/src/exec.rs

@@ -75,11 +75,12 @@ pub type ExecResult = Result<ExecReturnValue, ExecError>;
 /// wrap the error string into an ExecutionError with the provided buffer and return from the
 /// enclosing function. This macro is used instead of .map_err(..)? in order to avoid taking
 /// ownership of buffer unless there is an error.
+#[macro_export]
 macro_rules! try_or_exec_error {
 	($e:expr, $buffer:expr) => {
 		match $e {
 			Ok(val) => val,
-			Err(reason) => return Err(ExecError { reason, buffer: $buffer }),
+			Err(reason) => return Err($crate::exec::ExecError { reason, buffer: $buffer }),
 		}
 	}
 }
@@ -191,15 +192,6 @@ pub trait Loader<T: Trait> {
 	fn load_main(&self, code_hash: &CodeHash<T>) -> Result<Self::Executable, &'static str>;
 }
 
-/// Struct that records a request to deposit an event with a list of topics.
-#[cfg_attr(any(feature = "std", test), derive(Debug, PartialEq, Eq))]
-pub struct IndexedEvent<T: Trait> {
-	/// A list of topics this event will be deposited with.
-	pub topics: Vec<T::Hash>,
-	/// The event to deposit.
-	pub event: Event<T>,
-}
-
 /// A trait that represent a virtual machine.
 ///
 /// You can view a virtual machine as something that takes code, an input data buffer,

substrate/srml/contracts/src/lib.rs

@@ -98,11 +98,13 @@ mod rent;
 #[cfg(test)]
 mod tests;
 
-use crate::exec::{ExecutionContext, ExecResult};
+use crate::exec::ExecutionContext;
 use crate::account_db::{AccountDb, DirectAccountDb};
-pub use crate::gas::{Gas, GasMeter};
 use crate::wasm::{WasmLoader, WasmVm};
 
+pub use crate::gas::{Gas, GasMeter};
+pub use crate::exec::{ExecResult, ExecReturnValue, ExecError, StatusCode};
+
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
 use primitives::crypto::UncheckedFrom;
@@ -573,9 +575,9 @@ decl_module! {
 			let origin = ensure_signed(origin)?;
 			let dest = T::Lookup::lookup(dest)?;
 
-			Self::execute_wasm(origin, gas_limit, |ctx, gas_meter| {
-				ctx.call(dest, value, gas_meter, data)
-			})
+			Self::bare_call(origin, dest, value, gas_limit, data)
+				.map(|_| ())
+				.map_err(|e| e.reason)
 		}
 
 		/// Creates a new contract from the `codehash` generated by `put_code`, optionally transferring some balance.
@@ -601,6 +603,8 @@ decl_module! {
 				ctx.instantiate(endowment, gas_meter, &code_hash, data)
 					.map(|(_address, output)| output)
 			})
+			.map(|_| ())
+			.map_err(|e| e.reason)
 		}
 
 		/// Allows block producers to claim a small reward for evicting a contract. If a block producer
@@ -645,16 +649,37 @@ decl_module! {
 }
 
 impl<T: Trait> Module<T> {
+	/// Perform a call to a specified contract.
+	///
+	/// This function is similar to `Self::call`, but doesn't perform any lookups and better
+	/// suitable for calling directly from Rust.
+	pub fn bare_call(
+		origin: T::AccountId,
+		dest: T::AccountId,
+		value: BalanceOf<T>,
+		gas_limit: Gas,
+		input_data: Vec<u8>,
+	) -> ExecResult {
+		Self::execute_wasm(origin, gas_limit, |ctx, gas_meter| {
+			ctx.call(dest, value, gas_meter, input_data)
+		})
+	}
+
 	fn execute_wasm(
 		origin: T::AccountId,
 		gas_limit: Gas,
 		func: impl FnOnce(&mut ExecutionContext<T, WasmVm, WasmLoader>, &mut GasMeter<T>) -> ExecResult
-	) -> Result {
+	) -> ExecResult {
 		// Pay for the gas upfront.
 		//
 		// NOTE: it is very important to avoid any state changes before
 		// paying for the gas.
-		let (mut gas_meter, imbalance) = gas::buy_gas::<T>(&origin, gas_limit)?;
+		let (mut gas_meter, imbalance) =
+			try_or_exec_error!(
+				gas::buy_gas::<T>(&origin, gas_limit),
+				// We don't have a spare buffer here in the first place, so create a new empty one.
+				Vec::new()
+			);
 
 		let cfg = Config::preload();
 		let vm = WasmVm::new(&cfg.schedule);
@@ -705,8 +730,6 @@ impl<T: Trait> Module<T> {
 		});
 
 		result
-			.map(|_| ())
-			.map_err(|e| e.reason)
 	}
 
 	fn restore_to(