use std::sync::Arc;
use codec::Codec;
use tetsy_jsonrpc_core::{Error, ErrorCode, Result};
use tetsy_jsonrpc_derive::rpc;
use noble_contracts_primitives::RentProjection;
use serde::{Deserialize, Serialize};
use tp_api::ProvideRuntimeApi;
use tp_blockchain::HeaderBackend;
use tet_core::{Bytes, H256};
use tp_rpc::number;
use tp_runtime::{
generic::BlockId,
traits::{Block as BlockT, Header as HeaderT},
DispatchError,
};
use std::convert::{TryFrom, TryInto};
use noble_contracts_primitives::ContractExecResult;
pub use noble_contracts_rpc_runtime_api::ContractsApi as ContractsRuntimeApi;
const RUNTIME_ERROR: i64 = 1;
const CONTRACT_DOESNT_EXIST: i64 = 2;
const CONTRACT_IS_A_TOMBSTONE: i64 = 3;
const GAS_PER_SECOND: u64 = 1_000_000_000_000;
struct ContractAccessError(noble_contracts_primitives::ContractAccessError);
impl From<ContractAccessError> for Error {
fn from(e: ContractAccessError) -> Error {
use noble_contracts_primitives::ContractAccessError::*;
match e.0 {
DoesntExist => Error {
code: ErrorCode::ServerError(CONTRACT_DOESNT_EXIST),
message: "The specified contract doesn't exist.".into(),
data: None,
},
IsTombstone => Error {
code: ErrorCode::ServerError(CONTRACT_IS_A_TOMBSTONE),
message: "The contract is a tombstone and doesn't have any storage.".into(),
data: None,
},
}
}
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
pub struct CallRequest<AccountId> {
origin: AccountId,
dest: AccountId,
value: number::NumberOrHex,
gas_limit: number::NumberOrHex,
input_data: Bytes,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
struct RpcContractExecSuccess {
flags: u32,
data: Bytes,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "camelCase")]
pub struct RpcContractExecResult {
gas_consumed: u64,
debug_message: String,
result: std::result::Result<RpcContractExecSuccess, DispatchError>,
}
impl From<ContractExecResult> for RpcContractExecResult {
fn from(r: ContractExecResult) -> Self {
match r.exec_result {
Ok(val) => RpcContractExecResult {
gas_consumed: r.gas_consumed,
debug_message: String::new(),
result: Ok(RpcContractExecSuccess {
flags: val.flags.bits(),
data: val.data.into(),
}),
},
Err(err) => RpcContractExecResult {
gas_consumed: r.gas_consumed,
debug_message: String::new(),
result: Err(err.error),
},
}
}
}
#[rpc]
pub trait ContractsApi<BlockHash, BlockNumber, AccountId, Balance> {
#[rpc(name = "contracts_call")]
fn call(
&self,
call_request: CallRequest<AccountId>,
at: Option<BlockHash>,
) -> Result<RpcContractExecResult>;
#[rpc(name = "contracts_getStorage")]
fn get_storage(
&self,
address: AccountId,
key: H256,
at: Option<BlockHash>,
) -> Result<Option<Bytes>>;
#[rpc(name = "contracts_rentProjection")]
fn rent_projection(
&self,
address: AccountId,
at: Option<BlockHash>,
) -> Result<Option<BlockNumber>>;
}
pub struct Contracts<C, B> {
client: Arc<C>,
_marker: std::marker::PhantomData<B>,
}
impl<C, B> Contracts<C, B> {
pub fn new(client: Arc<C>) -> Self {
Contracts {
client,
_marker: Default::default(),
}
}
}
impl<C, Block, AccountId, Balance>
ContractsApi<
<Block as BlockT>::Hash,
<<Block as BlockT>::Header as HeaderT>::Number,
AccountId,
Balance,
> for Contracts<C, Block>
where
Block: BlockT,
C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
C::Api: ContractsRuntimeApi<
Block,
AccountId,
Balance,
<<Block as BlockT>::Header as HeaderT>::Number,
>,
AccountId: Codec,
Balance: Codec + TryFrom<number::NumberOrHex>,
{
fn call(
&self,
call_request: CallRequest<AccountId>,
at: Option<<Block as BlockT>::Hash>,
) -> Result<RpcContractExecResult> {
let api = self.client.runtime_api();
let at = BlockId::hash(at.unwrap_or_else(||
self.client.info().best_hash));
let CallRequest {
origin,
dest,
value,
gas_limit,
input_data,
} = call_request;
let value: Balance = value.try_into().map_err(|_| Error {
code: ErrorCode::InvalidParams,
message: format!("{:?} doesn't fit into the balance type", value),
data: None,
})?;
let gas_limit: u64 = gas_limit.try_into().map_err(|_| Error {
code: ErrorCode::InvalidParams,
message: format!("{:?} doesn't fit in 64 bit unsigned value", gas_limit),
data: None,
})?;
let max_gas_limit = 5 * GAS_PER_SECOND;
if gas_limit > max_gas_limit {
return Err(Error {
code: ErrorCode::InvalidParams,
message: format!(
"Requested gas limit is greater than maximum allowed: {} > {}",
gas_limit, max_gas_limit
),
data: None,
});
}
let exec_result = api
.call(&at, origin, dest, value, gas_limit, input_data.to_vec())
.map_err(runtime_error_into_rpc_err)?;
Ok(exec_result.into())
}
fn get_storage(
&self,
address: AccountId,
key: H256,
at: Option<<Block as BlockT>::Hash>,
) -> Result<Option<Bytes>> {
let api = self.client.runtime_api();
let at = BlockId::hash(at.unwrap_or_else(||
self.client.info().best_hash));
let result = api
.get_storage(&at, address, key.into())
.map_err(runtime_error_into_rpc_err)?
.map_err(ContractAccessError)?
.map(Bytes);
Ok(result)
}
fn rent_projection(
&self,
address: AccountId,
at: Option<<Block as BlockT>::Hash>,
) -> Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>> {
let api = self.client.runtime_api();
let at = BlockId::hash(at.unwrap_or_else(||
self.client.info().best_hash));
let result = api
.rent_projection(&at, address)
.map_err(runtime_error_into_rpc_err)?
.map_err(ContractAccessError)?;
Ok(match result {
RentProjection::NoEviction => None,
RentProjection::EvictionAt(block_num) => Some(block_num),
})
}
}
fn runtime_error_into_rpc_err(err: impl std::fmt::Debug) -> Error {
Error {
code: ErrorCode::ServerError(RUNTIME_ERROR),
message: "Runtime trapped".into(),
data: Some(format!("{:?}", err).into()),
}
}
#[cfg(test)]
mod tests {
use super::*;
use tet_core::U256;
#[test]
fn call_request_should_serialize_deserialize_properly() {
type Req = CallRequest<String>;
let req: Req = serde_json::from_str(r#"
{
"origin": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL",
"dest": "5DRakbLVnjVrW6niwLfHGW24EeCEvDAFGEXrtaYS5M4ynoom",
"value": "0x112210f4B16c1cb1",
"gasLimit": 1000000000000,
"inputData": "0x8c97db39"
}
"#).unwrap();
assert_eq!(req.gas_limit.into_u256(), U256::from(0xe8d4a51000u64));
assert_eq!(req.value.into_u256(), U256::from(1234567890987654321u128));
}
#[test]
fn result_should_serialize_deserialize_properly() {
fn test(expected: &str) {
let res: RpcContractExecResult = serde_json::from_str(expected).unwrap();
let actual = serde_json::to_string(&res).unwrap();
assert_eq!(actual, expected);
}
test(r#"{"gasConsumed":5000,"debugMessage":"helpOk","result":{"Ok":{"flags":5,"data":"0x1234"}}}"#);
test(r#"{"gasConsumed":3400,"debugMessage":"helpErr","result":{"Err":"BadOrigin"}}"#);
}
}