staking miner: reuse ws conn for remote-ext

utils/staking-miner/Cargo.toml

@@ -7,8 +7,8 @@ edition = "2018"
 [dependencies]
 clap = { version = "3.0", features = ["derive", "env"] }
 codec = { package = "parity-scale-codec", version = "2.0.0" }
-env_logger = "0.9.0"
-jsonrpsee = { version = "0.8", features = ["ws-client"] }
+tracing-subscriber = { version = "0.3.8", features = ["env-filter"]   }
+jsonrpsee = { version = "0.8", features = ["ws-client", "macros"] }
 log = "0.4.11"
 paste = "1.0.6"
 serde = "1.0.132"

utils/staking-miner/src/dry_run.rs

@@ -16,12 +16,10 @@
 
 //! The dry-run command.
 
-use crate::{
-	prelude::*, rpc_helpers::*, signer::Signer, DryRunConfig, Error, SharedConfig, WsClient,
-};
+use crate::{prelude::*, rpc::*, signer::Signer, DryRunConfig, Error, SharedRpcClient};
 use codec::Encode;
 use frame_support::traits::Currency;
-use jsonrpsee::rpc_params;
+use sp_core::Bytes;
 
 /// Forcefully create the snapshot. This can be used to compute the election at anytime.
 fn force_create_snapshot<T: EPM::Config>(ext: &mut Ext) -> Result<(), Error<T>> {
@@ -38,10 +36,10 @@ fn force_create_snapshot<T: EPM::Config>(ext: &mut Ext) -> Result<(), Error<T>>
 
 /// Helper method to print the encoded size of the snapshot.
 async fn print_info<T: EPM::Config>(
-	client: &WsClient,
+	rpc: &SharedRpcClient,
 	ext: &mut Ext,
 	raw_solution: &EPM::RawSolution<EPM::SolutionOf<T>>,
-	extrinsic: sp_core::Bytes,
+	extrinsic: &Bytes,
 ) where
 	<T as EPM::Config>::Currency: Currency<T::AccountId, Balance = Balance>,
 {
@@ -72,12 +70,8 @@ async fn print_info<T: EPM::Config>(
 		);
 	});
 
-	let info = rpc::<pallet_transaction_payment::RuntimeDispatchInfo<Balance>>(
-		client,
-		"payment_queryInfo",
-		rpc_params! { extrinsic },
-	)
-	.await;
+	let info = rpc.payment_query_info(&extrinsic, None).await;
+
 	log::info!(
 		target: LOG_TARGET,
 		"payment_queryInfo: (fee = {}) {:?}",
@@ -109,22 +103,21 @@ fn find_threshold<T: EPM::Config>(ext: &mut Ext, count: usize) {
 macro_rules! dry_run_cmd_for { ($runtime:ident) => { paste::paste! {
 	/// Execute the dry-run command.
 	pub(crate) async fn [<dry_run_cmd_ $runtime>](
-		client: &WsClient,
-		shared: SharedConfig,
+		rpc: SharedRpcClient,
 		config: DryRunConfig,
 		signer: Signer,
 	) -> Result<(), Error<$crate::[<$runtime _runtime_exports>]::Runtime>> {
 		use $crate::[<$runtime _runtime_exports>]::*;
 		let mut ext = crate::create_election_ext::<Runtime, Block>(
-			shared.uri.clone(),
+			rpc.clone(),
 			config.at,
 			vec!["Staking".to_string(), "System".to_string()],
 		).await?;
 		force_create_snapshot::<Runtime>(&mut ext)?;
 
 		let (raw_solution, witness) = crate::mine_with::<Runtime>(&config.solver, &mut ext, false)?;
 
-		let nonce = crate::get_account_info::<Runtime>(client, &signer.account, config.at)
+		let nonce = crate::get_account_info::<Runtime>(&rpc, &signer.account, config.at.as_ref())
 			.await?
 			.map(|i| i.nonce)
 			.expect("signer account is checked to exist upon startup; it can only die if it \
@@ -136,7 +129,7 @@ macro_rules! dry_run_cmd_for { ($runtime:ident) => { paste::paste! {
 		let extrinsic = ext.execute_with(|| create_uxt(raw_solution.clone(), witness, signer.clone(), nonce, tip, era));
 
 		let bytes = sp_core::Bytes(extrinsic.encode().to_vec());
-		print_info::<Runtime>(client, &mut ext, &raw_solution, bytes.clone()).await;
+		print_info::<Runtime>(&rpc, &mut ext, &raw_solution, &bytes).await;
 
 		let feasibility_result = ext.execute_with(|| {
 			EPM::Pallet::<Runtime>::feasibility_check(raw_solution.clone(), EPM::ElectionCompute::Signed)
@@ -150,9 +143,8 @@ macro_rules! dry_run_cmd_for { ($runtime:ident) => { paste::paste! {
 		});
 		log::info!(target: LOG_TARGET, "dispatch result is {:?}", dispatch_result);
 
-		let outcome = rpc_decode::<sp_runtime::ApplyExtrinsicResult>(client, "system_dryRun", rpc_params!{ bytes })
-			.await
-			.map_err::<Error<Runtime>, _>(Into::into)?;
+		let dry_run_fut = rpc.dry_run(&bytes, None);
+		let outcome: sp_runtime::ApplyExtrinsicResult = await_request_and_decode(dry_run_fut).await.map_err::<Error<Runtime>, _>(Into::into)?;
 		log::info!(target: LOG_TARGET, "dry-run outcome is {:?}", outcome);
 		Ok(())
 	}

utils/staking-miner/src/emergency_solution.rs

@@ -16,19 +16,19 @@
 
 //! The emergency-solution command.
 
-use crate::{prelude::*, EmergencySolutionConfig, Error, SharedConfig};
+use crate::{prelude::*, EmergencySolutionConfig, Error, SharedRpcClient};
 use codec::Encode;
 use std::io::Write;
 
 macro_rules! emergency_solution_cmd_for { ($runtime:ident) => { paste::paste! {
 	/// Execute the emergency-solution command.
 	pub(crate) async fn [<emergency_solution_cmd_ $runtime>](
-		shared: SharedConfig,
+		client: SharedRpcClient,
 		config: EmergencySolutionConfig,
 	) -> Result<(), Error<$crate::[<$runtime _runtime_exports>]::Runtime>> {
 		use $crate::[<$runtime _runtime_exports>]::*;
 
-		let mut ext = crate::create_election_ext::<Runtime, Block>(shared.uri.clone(), config.at, vec![]).await?;
+		let mut ext = crate::create_election_ext::<Runtime, Block>(client, config.at, vec![]).await?;
 		let (raw_solution, _witness) = crate::mine_with::<Runtime>(&config.solver, &mut ext, false)?;
 
 		ext.execute_with(|| {