#![warn(missing_docs)]
pub mod client_ext;
pub use tc_client_api::{
execution_extensions::{ExecutionStrategies, ExecutionExtensions},
ForkBlocks, BadBlocks,
};
pub use tc_client_db::{Backend, self};
pub use tp_consensus;
pub use tc_executor::{NativeExecutor, WasmExecutionMethod, self};
pub use tp_keyring::{
AccountKeyring,
ed25519::Keyring as Ed25519Keyring,
sr25519::Keyring as Sr25519Keyring,
};
pub use tp_keystore::{SyncCryptoStorePtr, SyncCryptoStore};
pub use tp_runtime::{Storage, StorageChild};
pub use tp_state_machine::ExecutionStrategy;
pub use tc_service::{RpcHandlers, RpcSession, client};
pub use self::client_ext::{ClientExt, ClientBlockImportExt};
use std::pin::Pin;
use std::sync::Arc;
use std::collections::{HashSet, HashMap};
use futures::{future::{Future, FutureExt}, stream::StreamExt};
use serde::Deserialize;
use tet_core::storage::ChildInfo;
use tp_runtime::{OpaqueExtrinsic, codec::Encode, traits::{Block as BlockT, BlakeTwo256}};
use tc_service::client::{LocalCallExecutor, ClientConfig};
use tc_client_api::BlockchainEvents;
pub type LightBackend<Block> = tc_light::Backend<
tc_client_db::light::LightStorage<Block>,
BlakeTwo256,
>;
pub trait GenesisInit: Default {
fn genesis_storage(&self) -> Storage;
}
impl GenesisInit for () {
fn genesis_storage(&self) -> Storage {
Default::default()
}
}
pub struct TestClientBuilder<Block: BlockT, Executor, Backend, G: GenesisInit> {
execution_strategies: ExecutionStrategies,
genesis_init: G,
child_storage_extension: HashMap<Vec<u8>, StorageChild>,
backend: Arc<Backend>,
_executor: std::marker::PhantomData<Executor>,
keystore: Option<SyncCryptoStorePtr>,
fork_blocks: ForkBlocks<Block>,
bad_blocks: BadBlocks<Block>,
enable_offchain_indexing_api: bool,
}
impl<Block: BlockT, Executor, G: GenesisInit> Default
for TestClientBuilder<Block, Executor, Backend<Block>, G> {
fn default() -> Self {
Self::with_default_backend()
}
}
impl<Block: BlockT, Executor, G: GenesisInit> TestClientBuilder<Block, Executor, Backend<Block>, G> {
pub fn with_default_backend() -> Self {
let backend = Arc::new(Backend::new_test(std::u32::MAX, std::u64::MAX));
Self::with_backend(backend)
}
pub fn with_pruning_window(keep_blocks: u32) -> Self {
let backend = Arc::new(Backend::new_test(keep_blocks, 0));
Self::with_backend(backend)
}
}
impl<Block: BlockT, Executor, Backend, G: GenesisInit> TestClientBuilder<Block, Executor, Backend, G> {
pub fn with_backend(backend: Arc<Backend>) -> Self {
TestClientBuilder {
backend,
execution_strategies: ExecutionStrategies::default(),
child_storage_extension: Default::default(),
genesis_init: Default::default(),
_executor: Default::default(),
keystore: None,
fork_blocks: None,
bad_blocks: None,
enable_offchain_indexing_api: false,
}
}
pub fn set_keystore(mut self, keystore: SyncCryptoStorePtr) -> Self {
self.keystore = Some(keystore);
self
}
pub fn genesis_init_mut(&mut self) -> &mut G {
&mut self.genesis_init
}
pub fn backend(&self) -> Arc<Backend> {
self.backend.clone()
}
pub fn add_child_storage(
mut self,
child_info: &ChildInfo,
key: impl AsRef<[u8]>,
value: impl AsRef<[u8]>,
) -> Self {
let storage_key = child_info.storage_key();
let entry = self.child_storage_extension.entry(storage_key.to_vec())
.or_insert_with(|| StorageChild {
data: Default::default(),
child_info: child_info.clone(),
});
entry.data.insert(key.as_ref().to_vec(), value.as_ref().to_vec());
self
}
pub fn set_execution_strategy(
mut self,
execution_strategy: ExecutionStrategy
) -> Self {
self.execution_strategies = ExecutionStrategies {
syncing: execution_strategy,
importing: execution_strategy,
block_construction: execution_strategy,
offchain_worker: execution_strategy,
other: execution_strategy,
};
self
}
pub fn set_block_rules(mut self,
fork_blocks: ForkBlocks<Block>,
bad_blocks: BadBlocks<Block>,
) -> Self {
self.fork_blocks = fork_blocks;
self.bad_blocks = bad_blocks;
self
}
pub fn enable_offchain_indexing_api(mut self) -> Self {
self.enable_offchain_indexing_api = true;
self
}
pub fn build_with_executor<RuntimeApi>(
self,
executor: Executor,
) -> (
client::Client<
Backend,
Executor,
Block,
RuntimeApi,
>,
tc_consensus::LongestChain<Backend, Block>,
) where
Executor: tc_client_api::CallExecutor<Block> + 'static,
Backend: tc_client_api::backend::Backend<Block>,
{
let storage = {
let mut storage = self.genesis_init.genesis_storage();
for (key, child_content) in self.child_storage_extension {
storage.children_default.insert(
key,
StorageChild {
data: child_content.data.into_iter().collect(),
child_info: child_content.child_info,
},
);
}
storage
};
let client = client::Client::new(
self.backend.clone(),
executor,
&storage,
self.fork_blocks,
self.bad_blocks,
ExecutionExtensions::new(
self.execution_strategies,
self.keystore,
),
None,
ClientConfig {
offchain_indexing_api: self.enable_offchain_indexing_api,
..Default::default()
},
).expect("Creates new client");
let longest_chain = tc_consensus::LongestChain::new(self.backend);
(client, longest_chain)
}
}
impl<Block: BlockT, E, Backend, G: GenesisInit> TestClientBuilder<
Block,
client::LocalCallExecutor<Backend, NativeExecutor<E>>,
Backend,
G,
> {
pub fn build_with_native_executor<RuntimeApi, I>(
self,
executor: I,
) -> (
client::Client<
Backend,
client::LocalCallExecutor<Backend, NativeExecutor<E>>,
Block,
RuntimeApi
>,
tc_consensus::LongestChain<Backend, Block>,
) where
I: Into<Option<NativeExecutor<E>>>,
E: tc_executor::NativeExecutionDispatch + 'static,
Backend: tc_client_api::backend::Backend<Block> + 'static,
{
let executor = executor.into().unwrap_or_else(||
NativeExecutor::new(WasmExecutionMethod::Interpreted, None, 8)
);
let executor = LocalCallExecutor::new(
self.backend.clone(),
executor,
Box::new(tet_core::testing::TaskExecutor::new()),
Default::default(),
).expect("Creates LocalCallExecutor");
self.build_with_executor(executor)
}
}
pub struct RpcTransactionOutput {
pub result: Option<String>,
pub session: RpcSession,
pub receiver: futures01::sync::mpsc::Receiver<String>,
}
impl std::fmt::Debug for RpcTransactionOutput {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "RpcTransactionOutput {{ result: {:?}, session, receiver }}", self.result)
}
}
#[derive(Deserialize, Debug)]
pub struct RpcTransactionError {
pub code: i64,
pub message: String,
pub data: Option<serde_json::Value>,
}
impl std::fmt::Display for RpcTransactionError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Debug::fmt(self, f)
}
}
pub trait RpcHandlersExt {
fn send_transaction(
&self,
extrinsic: OpaqueExtrinsic,
) -> Pin<Box<dyn Future<Output = Result<RpcTransactionOutput, RpcTransactionError>> + Send>>;
}
impl RpcHandlersExt for RpcHandlers {
fn send_transaction(
&self,
extrinsic: OpaqueExtrinsic,
) -> Pin<Box<dyn Future<Output = Result<RpcTransactionOutput, RpcTransactionError>> + Send>> {
let (tx, rx) = futures01::sync::mpsc::channel(0);
let mem = RpcSession::new(tx.into());
Box::pin(self
.rpc_query(
&mem,
&format!(
r#"{{
"jsonrpc": "2.0",
"method": "author_submitExtrinsic",
"params": ["0x{}"],
"id": 0
}}"#,
hex::encode(extrinsic.encode())
),
)
.map(move |result| parse_rpc_result(result, mem, rx))
)
}
}
pub(crate) fn parse_rpc_result(
result: Option<String>,
session: RpcSession,
receiver: futures01::sync::mpsc::Receiver<String>,
) -> Result<RpcTransactionOutput, RpcTransactionError> {
if let Some(ref result) = result {
let json: serde_json::Value = serde_json::from_str(result)
.expect("the result can only be a JSONRPC string; qed");
let error = json
.as_object()
.expect("JSON result is always an object; qed")
.get("error");
if let Some(error) = error {
return Err(
serde_json::from_value(error.clone())
.expect("the JSONRPC result's error is always valid; qed")
)
}
}
Ok(RpcTransactionOutput {
result,
session,
receiver,
})
}
pub trait BlockchainEventsExt<C, B>
where
C: BlockchainEvents<B>,
B: BlockT,
{
fn wait_for_blocks(&self, count: usize) -> Pin<Box<dyn Future<Output = ()> + Send>>;
}
impl<C, B> BlockchainEventsExt<C, B> for C
where
C: BlockchainEvents<B>,
B: BlockT,
{
fn wait_for_blocks(&self, count: usize) -> Pin<Box<dyn Future<Output = ()> + Send>> {
assert!(count > 0, "'count' argument must be greater than 0");
let mut import_notification_stream = self.import_notification_stream();
let mut blocks = HashSet::new();
Box::pin(async move {
while let Some(notification) = import_notification_stream.next().await {
if notification.is_new_best {
blocks.insert(notification.hash);
if blocks.len() == count {
break;
}
}
}
})
}
}
#[cfg(test)]
mod tests {
use tc_service::RpcSession;
fn create_session_and_receiver() -> (RpcSession, futures01::sync::mpsc::Receiver<String>) {
let (tx, rx) = futures01::sync::mpsc::channel(0);
let mem = RpcSession::new(tx.into());
(mem, rx)
}
#[test]
fn parses_error_properly() {
let (mem, rx) = create_session_and_receiver();
assert!(super::parse_rpc_result(None, mem, rx).is_ok());
let (mem, rx) = create_session_and_receiver();
assert!(
super::parse_rpc_result(Some(r#"{
"jsonrpc": "2.0",
"result": 19,
"id": 1
}"#.to_string()), mem, rx)
.is_ok(),
);
let (mem, rx) = create_session_and_receiver();
let error = super::parse_rpc_result(Some(r#"{
"jsonrpc": "2.0",
"error": {
"code": -32601,
"message": "Method not found"
},
"id": 1
}"#.to_string()), mem, rx)
.unwrap_err();
assert_eq!(error.code, -32601);
assert_eq!(error.message, "Method not found");
assert!(error.data.is_none());
let (mem, rx) = create_session_and_receiver();
let error = super::parse_rpc_result(Some(r#"{
"jsonrpc": "2.0",
"error": {
"code": -32601,
"message": "Method not found",
"data": 42
},
"id": 1
}"#.to_string()), mem, rx)
.unwrap_err();
assert_eq!(error.code, -32601);
assert_eq!(error.message, "Method not found");
assert!(error.data.is_some());
}
}