Change submit transaction spec_version and transaction_version query from chain (#1248)

* The `spec_version` and `transaction_version` query from chain

* fix compile

* Lint

* Custom spec_version and transaction_version

* runtime version params struct opt

* runtime version cli

* cli params

* Add missing types defined

* fix compile

* debug cli

* clippy

* clippy

* Query spec_version and transaction_version same times

* Fix vars

* Wrap option

* Wrap option

* Try fix ci

* Change follow suggestions

bridges/relays/client-substrate/src/chain.rs

@@ -172,12 +172,9 @@ pub trait TransactionSignScheme {
 	type SignedTransaction: Clone + Debug + Codec + Send + 'static;
 
 	/// Create transaction for given runtime call, signed by given account.
-	fn sign_transaction(
-		genesis_hash: <Self::Chain as ChainBase>::Hash,
-		signer: &Self::AccountKeyPair,
-		era: TransactionEraOf<Self::Chain>,
-		unsigned: UnsignedTransaction<Self::Chain>,
-	) -> Self::SignedTransaction;
+	fn sign_transaction(param: SignParam<Self>) -> Self::SignedTransaction
+	where
+		Self: Sized;
 
 	/// Returns true if transaction is signed.
 	fn is_signed(tx: &Self::SignedTransaction) -> bool;
@@ -191,6 +188,22 @@ pub trait TransactionSignScheme {
 	fn parse_transaction(tx: Self::SignedTransaction) -> Option<UnsignedTransaction<Self::Chain>>;
 }
 
+/// Sign transaction parameters
+pub struct SignParam<T: TransactionSignScheme> {
+	/// Version of the runtime specification.
+	pub spec_version: u32,
+	/// Transaction version
+	pub transaction_version: u32,
+	/// Hash of the genesis block.
+	pub genesis_hash: <T::Chain as ChainBase>::Hash,
+	/// Signer account
+	pub signer: T::AccountKeyPair,
+	/// Transaction era used by the chain.
+	pub era: TransactionEraOf<T::Chain>,
+	/// Transaction before it is signed.
+	pub unsigned: UnsignedTransaction<T::Chain>,
+}
+
 impl<Block: BlockT> BlockWithJustification<Block::Header> for SignedBlock<Block> {
 	fn header(&self) -> Block::Header {
 		self.block.header().clone()

bridges/relays/client-substrate/src/client.rs

@@ -60,6 +60,17 @@ pub struct Subscription<T>(Mutex<futures::channel::mpsc::Receiver<Option<T>>>);
 /// Opaque GRANDPA authorities set.
 pub type OpaqueGrandpaAuthoritiesSet = Vec<u8>;
 
+/// Chain runtime version in client
+#[derive(Clone, Debug)]
+pub enum ChainRuntimeVersion {
+	/// Auto query from chain.
+	Auto,
+	/// Custom runtime version, defined by user.
+	/// the first is `spec_version`
+	/// the second is `transaction_version`
+	Custom(u32, u32),
+}
+
 /// Substrate client type.
 ///
 /// Cloning `Client` is a cheap operation.
@@ -77,6 +88,8 @@ pub struct Client<C: Chain> {
 	/// transactions will be rejected from the pool. This lock is here to prevent situations like
 	/// that.
 	submit_signed_extrinsic_lock: Arc<Mutex<()>>,
+	/// Saved chain runtime version
+	chain_runtime_version: ChainRuntimeVersion,
 }
 
 #[async_trait]
@@ -99,6 +112,7 @@ impl<C: Chain> Clone for Client<C> {
 			client: self.client.clone(),
 			genesis_hash: self.genesis_hash,
 			submit_signed_extrinsic_lock: self.submit_signed_extrinsic_lock.clone(),
+			chain_runtime_version: self.chain_runtime_version.clone(),
 		}
 	}
 }
@@ -144,12 +158,14 @@ impl<C: Chain> Client<C> {
 			})
 			.await??;
 
+		let chain_runtime_version = params.chain_runtime_version.clone();
 		Ok(Self {
 			tokio,
 			params,
 			client,
 			genesis_hash,
 			submit_signed_extrinsic_lock: Arc::new(Mutex::new(())),
+			chain_runtime_version,
 		})
 	}
 
@@ -178,6 +194,19 @@ impl<C: Chain> Client<C> {
 }
 
 impl<C: Chain> Client<C> {
+	/// Return simple runtime version, only include `spec_version` and `transaction_version`.
+	pub async fn simple_runtime_version(&self) -> Result<(u32, u32)> {
+		let (spec_version, transaction_version) = match self.chain_runtime_version {
+			ChainRuntimeVersion::Auto => {
+				let runtime_version = self.runtime_version().await?;
+				(runtime_version.spec_version, runtime_version.transaction_version)
+			},
+			ChainRuntimeVersion::Custom(spec_version, transaction_version) =>
+				(spec_version, transaction_version),
+		};
+		Ok((spec_version, transaction_version))
+	}
+
 	/// Returns true if client is connected to at least one peer and is in synced state.
 	pub async fn ensure_synced(&self) -> Result<()> {
 		self.jsonrpsee_execute(|client| async move {

bridges/relays/client-substrate/src/lib.rs

@@ -32,10 +32,10 @@ use std::time::Duration;
 pub use crate::{
 	chain::{
 		AccountKeyPairOf, BlockWithJustification, CallOf, Chain, ChainWithBalances,
-		ChainWithMessages, TransactionSignScheme, TransactionStatusOf, UnsignedTransaction,
-		WeightToFeeOf,
+		ChainWithMessages, SignParam, TransactionSignScheme, TransactionStatusOf,
+		UnsignedTransaction, WeightToFeeOf,
 	},
-	client::{Client, OpaqueGrandpaAuthoritiesSet, Subscription},
+	client::{ChainRuntimeVersion, Client, OpaqueGrandpaAuthoritiesSet, Subscription},
 	error::{Error, Result},
 	sync_header::SyncHeader,
 };
@@ -56,11 +56,18 @@ pub struct ConnectionParams {
 	pub port: u16,
 	/// Use secure websocket connection.
 	pub secure: bool,
+	/// Defined chain runtime version
+	pub chain_runtime_version: ChainRuntimeVersion,
 }
 
 impl Default for ConnectionParams {
 	fn default() -> Self {
-		ConnectionParams { host: "localhost".into(), port: 9944, secure: false }
+		ConnectionParams {
+			host: "localhost".into(),
+			port: 9944,
+			secure: false,
+			chain_runtime_version: ChainRuntimeVersion::Auto,
+		}
 	}
 }