diff --git a/Cargo.lock b/Cargo.lock index 4954c736a6a0d..0d257d6dd0368 100644 --- a/Cargo.lock +++ b/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" diff --git a/Cargo.toml b/Cargo.toml index 1920587440dbe..bc9fd128ff145 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -42,6 +42,7 @@ members = [ "core/panic-handler", "core/primitives", "core/rpc", + "core/rpc/primitives", "core/rpc-servers", "core/serializer", "core/service", diff --git a/core/rpc/Cargo.toml b/core/rpc/Cargo.toml index 25f0a467ee7c1..5bf74cf42e869 100644 --- a/core/rpc/Cargo.toml +++ b/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" } diff --git a/core/rpc/api/Cargo.toml b/core/rpc/api/Cargo.toml index 4b09f4f3270c2..4b2eb613dbfd8 100644 --- a/core/rpc/api/Cargo.toml +++ b/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" } diff --git a/core/rpc/api/src/chain/mod.rs b/core/rpc/api/src/chain/mod.rs index c0076d5987a37..73f4388236cc8 100644 --- a/core/rpc/api/src/chain/mod.rs +++ b/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; diff --git a/core/rpc/primitives/Cargo.toml b/core/rpc/primitives/Cargo.toml new file mode 100644 index 0000000000000..fab94a86ba496 --- /dev/null +++ b/core/rpc/primitives/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "substrate-rpc-primitives" +version = "2.0.0" +authors = ["Parity Technologies "] +edition = "2018" + +[dependencies] +serde = { version = "1.0", features = ["derive"] } +primitives = { package = "substrate-primitives", path = "../../primitives" } diff --git a/core/rpc/primitives/src/lib.rs b/core/rpc/primitives/src/lib.rs new file mode 100644 index 0000000000000..667b1b1b4b4f9 --- /dev/null +++ b/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 . + +//! Substrate RPC primitives and utilities. + +#![warn(missing_docs)] + +pub mod number; diff --git a/core/rpc/api/src/chain/number.rs b/core/rpc/primitives/src/number.rs similarity index 100% rename from core/rpc/api/src/chain/number.rs rename to core/rpc/primitives/src/number.rs diff --git a/core/rpc/src/chain/mod.rs b/core/rpc/src/chain/mod.rs index 4c59d227c2dc4..61ecf96711383 100644 --- a/core/rpc/src/chain/mod.rs +++ b/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}, diff --git a/node/cli/src/service.rs b/node/cli/src/service.rs index c6ad072ef5f92..ca6b249484e07 100644 --- a/node/cli/src/service.rs +++ b/node/cli/src/service.rs @@ -270,11 +270,17 @@ pub fn new_light(config: Configuration; /// 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, + }, + /// 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, + ) -> ContractExecResult; + } } diff --git a/node/rpc/Cargo.toml b/node/rpc/Cargo.toml index 55371daad6b0f..3485357053975 100644 --- a/node/rpc/Cargo.toml +++ b/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] diff --git a/node/rpc/src/accounts.rs b/node/rpc/src/accounts.rs index 09d4a5144228c..9586b8b3893b9 100644 --- a/node/rpc/src/accounts.rs +++ b/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()), })?; diff --git a/node/rpc/src/contracts.rs b/node/rpc/src/contracts.rs new file mode 100644 index 0000000000000..3da2478dab8bf --- /dev/null +++ b/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 . + +//! 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, + input_data: Vec, +} + +/// Contracts RPC methods. +#[rpc] +pub trait ContractsApi { + /// 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, + ) -> Result; +} + +/// An implementation of contract specific RPC methods. +pub struct Contracts { + client: Arc, +} + +impl Contracts { + /// Create new `Contracts` with the given reference to the client. + pub fn new(client: Arc) -> Self { + Contracts { client } + } +} + +impl ContractsApi<::Hash> for Contracts +where + C: Send + Sync + 'static, + C: traits::ProvideRuntimeApi, + C: HeaderBackend, + C::Api: ContractsRuntimeApi, +{ + fn call( + &self, + call_request: CallRequest, + at: Option<::Hash>, + ) -> Result { + 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) + } +} diff --git a/node/rpc/src/lib.rs b/node/rpc/src/lib.rs index e25424397d6cf..0d23c40a34de0 100644 --- a/node/rpc/src/lib.rs +++ b/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; +} diff --git a/node/runtime/src/lib.rs b/node/runtime/src/lib.rs index 72a533ada89b6..0a30e09f5e69f 100644 --- a/node/runtime/src/lib.rs +++ b/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 for Runtime { + fn call( + origin: AccountId, + dest: AccountId, + value: Balance, + gas_limit: u64, + input_data: Vec, + ) -> 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 for Runtime { fn generate_session_keys(seed: Option>) -> Vec { let seed = seed.as_ref().map(|s| rstd::str::from_utf8(&s).expect("Seed is an utf8 string")); diff --git a/srml/contracts/src/exec.rs b/srml/contracts/src/exec.rs index 8308a9180c4ea..5f871f519eb44 100644 --- a/srml/contracts/src/exec.rs +++ b/srml/contracts/src/exec.rs @@ -75,11 +75,12 @@ pub type ExecResult = Result; /// 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 { fn load_main(&self, code_hash: &CodeHash) -> Result; } -/// 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 { - /// A list of topics this event will be deposited with. - pub topics: Vec, - /// The event to deposit. - pub event: Event, -} - /// A trait that represent a virtual machine. /// /// You can view a virtual machine as something that takes code, an input data buffer, diff --git a/srml/contracts/src/lib.rs b/srml/contracts/src/lib.rs index 74ad5867af3ca..ef4ccab721e4a 100644 --- a/srml/contracts/src/lib.rs +++ b/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 Module { + /// 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, + gas_limit: Gas, + input_data: Vec, + ) -> 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, &mut GasMeter) -> 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::(&origin, gas_limit)?; + let (mut gas_meter, imbalance) = + try_or_exec_error!( + gas::buy_gas::(&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 Module { }); result - .map(|_| ()) - .map_err(|e| e.reason) } fn restore_to(