Extract minimal Rialto-Sub and Millau-Sub clients (#365)

* extracting sub clients * fmt + lost docs * revert enum BridgeInstance * apply suggestions from review * explicite debug impl * remove unused imports from Millau * fix typo * fix instance + API name * Update relays/ethereum/src/ethereum_sync_loop.rs Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com> * separate crates for millau and rialto client * cargo fmt * fix * fmt * remove no_std support * fix compilation again * Update relays/substrate-client/Cargo.toml * Update relay clients to Substrate 2.0 Co-authored-by: Hernando Castano <HCastano@users.noreply.github.com> Co-authored-by: Hernando Castano <castano.ha@gmail.com>
2026-05-31 01:41:03 +00:00 · 2020-09-28 23:49:15 +03:00
parent 7f7d62d813
commit 52c1913fff
26 changed files with 1042 additions and 751 deletions
@@ -0,0 +1,87 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+use crate::client::Client;
+
+use frame_support::Parameter;
+use jsonrpsee::common::{DeserializeOwned, Serialize};
+use sp_core::Pair;
+use sp_runtime::traits::{
+	AtLeast32Bit, AtLeast32BitUnsigned, Bounded, CheckEqual, Dispatchable, Header as HeaderT, MaybeDisplay,
+	MaybeMallocSizeOf, MaybeSerialize, MaybeSerializeDeserialize, Member, SimpleBitOps,
+};
+use sp_std::fmt::Debug;
+
+/// Substrate-based chain from minimal relay-client point of view.
+pub trait Chain {
+	/// The block number type used by the runtime.
+	type BlockNumber: Parameter
+		+ Member
+		+ MaybeSerializeDeserialize
+		+ Debug
+		+ MaybeDisplay
+		+ AtLeast32BitUnsigned
+		+ Default
+		+ Bounded
+		+ Copy
+		+ sp_std::hash::Hash
+		+ sp_std::str::FromStr
+		+ MaybeMallocSizeOf;
+	/// The output of the `Hashing` function.
+	type Hash: Parameter
+		+ Member
+		+ MaybeSerializeDeserialize
+		+ Debug
+		+ MaybeDisplay
+		+ SimpleBitOps
+		+ Ord
+		+ Default
+		+ Copy
+		+ CheckEqual
+		+ sp_std::hash::Hash
+		+ AsRef<[u8]>
+		+ AsMut<[u8]>
+		+ MaybeMallocSizeOf;
+	/// The block header.
+	type Header: Parameter + HeaderT<Number = Self::BlockNumber, Hash = Self::Hash>;
+	/// The user account identifier type for the runtime.
+	type AccountId: Parameter + Member + MaybeSerializeDeserialize + Debug + MaybeDisplay + Ord + Default;
+	/// Account index (aka nonce) type. This stores the number of previous transactions associated
+	/// with a sender account.
+	type Index: Parameter + Member + MaybeSerialize + Debug + Default + MaybeDisplay + AtLeast32Bit + Copy;
+	/// Block type.
+	type SignedBlock: Member + Serialize + DeserializeOwned;
+	/// The aggregated `Call` type.
+	type Call: Dispatchable + Debug;
+}
+
+/// Substrate-based chain transactions signing scheme.
+pub trait TransactionSignScheme {
+	/// Chain that this scheme is to be used.
+	type Chain: Chain;
+	/// Type of key pairs used to sign transactions.
+	type AccountKeyPair: Pair;
+	/// Signed transaction.
+	type SignedTransaction;
+
+	/// Create transaction for given runtime call, signed by given account.
+	fn sign_transaction(
+		client: &Client<Self::Chain>,
+		signer: &Self::AccountKeyPair,
+		signer_nonce: <Self::Chain as Chain>::Index,
+		call: <Self::Chain as Chain>::Call,
+	) -> Self::SignedTransaction;
+}
@@ -0,0 +1,135 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate node client.
+
+use crate::chain::Chain;
+use crate::rpc::Substrate;
+use crate::{ConnectionParams, Result};
+
+use jsonrpsee::common::DeserializeOwned;
+use jsonrpsee::raw::RawClient;
+use jsonrpsee::transport::http::HttpTransportClient;
+use jsonrpsee::Client as RpcClient;
+use num_traits::Zero;
+use sp_core::Bytes;
+
+const SUB_API_GRANDPA_AUTHORITIES: &str = "GrandpaApi_grandpa_authorities";
+
+/// Opaque GRANDPA authorities set.
+pub type OpaqueGrandpaAuthoritiesSet = Vec<u8>;
+
+/// Substrate client type.
+pub struct Client<C: Chain> {
+	/// Substrate RPC client.
+	client: RpcClient,
+	/// Genesis block hash.
+	genesis_hash: C::Hash,
+}
+
+impl<C: Chain> std::fmt::Debug for Client<C> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.debug_struct("Client")
+			.field("genesis_hash", &self.genesis_hash)
+			.finish()
+	}
+}
+
+impl<C: Chain> Client<C> {
+	/// Returns client that is able to call RPCs on Substrate node.
+	pub async fn new(params: ConnectionParams) -> Result<Self> {
+		let uri = format!("http://{}:{}", params.host, params.port);
+		let transport = HttpTransportClient::new(&uri);
+		let raw_client = RawClient::new(transport);
+		let client: RpcClient = raw_client.into();
+
+		let number: C::BlockNumber = Zero::zero();
+		let genesis_hash = Substrate::<C, _, _>::chain_get_block_hash(&client, number).await?;
+
+		Ok(Self { client, genesis_hash })
+	}
+}
+
+impl<C: Chain> Client<C>
+where
+	C::Header: DeserializeOwned,
+	C::Index: DeserializeOwned,
+{
+	/// Return hash of the genesis block.
+	pub fn genesis_hash(&self) -> &C::Hash {
+		&self.genesis_hash
+	}
+
+	/// Returns the best Substrate header.
+	pub async fn best_header(&self) -> Result<C::Header> {
+		Ok(Substrate::<C, _, _>::chain_get_header(&self.client, None).await?)
+	}
+
+	/// Get a Substrate block from its hash.
+	pub async fn get_block(&self, block_hash: Option<C::Hash>) -> Result<C::SignedBlock> {
+		Ok(Substrate::<C, _, _>::chain_get_block(&self.client, block_hash).await?)
+	}
+
+	/// Get a Substrate header by its hash.
+	pub async fn header_by_hash(&self, block_hash: C::Hash) -> Result<C::Header> {
+		Ok(Substrate::<C, _, _>::chain_get_header(&self.client, block_hash).await?)
+	}
+
+	/// Get a Substrate block hash by its number.
+	pub async fn block_hash_by_number(&self, number: C::BlockNumber) -> Result<C::Hash> {
+		Ok(Substrate::<C, _, _>::chain_get_block_hash(&self.client, number).await?)
+	}
+
+	/// Get a Substrate header by its number.
+	pub async fn header_by_number(&self, block_number: C::BlockNumber) -> Result<C::Header> {
+		let block_hash = Self::block_hash_by_number(self, block_number).await?;
+		Ok(Self::header_by_hash(self, block_hash).await?)
+	}
+
+	/// Get the nonce of the given Substrate account.
+	///
+	/// Note: It's the caller's responsibility to make sure `account` is a valid ss58 address.
+	pub async fn next_account_index(&self, account: C::AccountId) -> Result<C::Index> {
+		Ok(Substrate::<C, _, _>::system_account_next_index(&self.client, account).await?)
+	}
+
+	/// Submit an extrinsic for inclusion in a block.
+	///
+	/// Note: The given transaction does not need be SCALE encoded beforehand.
+	pub async fn submit_extrinsic(&self, transaction: Bytes) -> Result<C::Hash> {
+		let tx_hash = Substrate::<C, _, _>::author_submit_extrinsic(&self.client, transaction).await?;
+		log::trace!(target: "bridge", "Sent transaction to Substrate node: {:?}", tx_hash);
+		Ok(tx_hash)
+	}
+
+	/// Get the GRANDPA authority set at given block.
+	pub async fn grandpa_authorities_set(&self, block: C::Hash) -> Result<OpaqueGrandpaAuthoritiesSet> {
+		let call = SUB_API_GRANDPA_AUTHORITIES.to_string();
+		let data = Bytes(Vec::new());
+
+		let encoded_response = Substrate::<C, _, _>::state_call(&self.client, call, data, Some(block)).await?;
+		let authority_list = encoded_response.0;
+
+		Ok(authority_list)
+	}
+
+	/// Execute runtime call at given block.
+	pub async fn state_call(&self, method: String, data: Bytes, at_block: Option<C::Hash>) -> Result<Bytes> {
+		Substrate::<C, _, _>::state_call(&self.client, method, data, at_block)
+			.await
+			.map_err(Into::into)
+	}
+}
@@ -0,0 +1,55 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate node RPC errors.
+
+use jsonrpsee::client::RequestError;
+use relay_utils::MaybeConnectionError;
+
+/// Result type used by Substrate client.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Errors that can occur only when interacting with
+/// a Substrate node through RPC.
+#[derive(Debug)]
+pub enum Error {
+	/// An error that can occur when making an HTTP request to
+	/// an JSON-RPC client.
+	Request(RequestError),
+	/// The response from the client could not be SCALE decoded.
+	ResponseParseFailed(codec::Error),
+}
+
+impl From<RequestError> for Error {
+	fn from(error: RequestError) -> Self {
+		Error::Request(error)
+	}
+}
+
+impl MaybeConnectionError for Error {
+	fn is_connection_error(&self) -> bool {
+		matches!(*self, Error::Request(RequestError::TransportError(_)))
+	}
+}
+
+impl ToString for Error {
+	fn to_string(&self) -> String {
+		match self {
+			Self::Request(e) => e.to_string(),
+			Self::ResponseParseFailed(e) => e.what().to_string(),
+		}
+	}
+}
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Tools to interact with (Open) Ethereum node using RPC methods.
+
+#![warn(missing_docs)]
+
+mod chain;
+mod client;
+mod error;
+mod rpc;
+
+pub use crate::chain::{Chain, TransactionSignScheme};
+pub use crate::client::{Client, OpaqueGrandpaAuthoritiesSet};
+pub use crate::error::{Error, Result};
+
+/// Substrate connection params.
+#[derive(Debug, Clone)]
+pub struct ConnectionParams {
+	/// Substrate RPC host.
+	pub host: String,
+	/// Substrate RPC port.
+	pub port: u16,
+}
+
+impl Default for ConnectionParams {
+	fn default() -> Self {
+		ConnectionParams {
+			host: "localhost".into(),
+			port: 9933,
+		}
+	}
+}
@@ -0,0 +1,43 @@
+// Copyright 2019-2020 Parity Technologies (UK) Ltd.
+// This file is part of Parity Bridges Common.
+
+// Parity Bridges Common 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.
+
+// Parity Bridges Common 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 Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
+
+//! The most generic Substrate node RPC interface.
+
+// The compiler doesn't think we're using the
+// code from rpc_api!
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+use crate::chain::Chain;
+
+use sp_core::Bytes;
+
+jsonrpsee::rpc_api! {
+	pub(crate) Substrate<C: Chain> {
+		#[rpc(method = "chain_getHeader", positional_params)]
+		fn chain_get_header(block_hash: Option<C::Hash>) -> C::Header;
+		#[rpc(method = "chain_getBlock", positional_params)]
+		fn chain_get_block(block_hash: Option<C::Hash>) -> C::SignedBlock;
+		#[rpc(method = "chain_getBlockHash", positional_params)]
+		fn chain_get_block_hash(block_number: Option<C::BlockNumber>) -> C::Hash;
+		#[rpc(method = "system_accountNextIndex", positional_params)]
+		fn system_account_next_index(account_id: C::AccountId) -> C::Index;
+		#[rpc(method = "author_submitExtrinsic", positional_params)]
+		fn author_submit_extrinsic(extrinsic: Bytes) -> C::Hash;
+		#[rpc(method = "state_call", positional_params)]
+		fn state_call(method: String, data: Bytes, at_block: Option<C::Hash>) -> Bytes;
+	}
+}