staking miner: reuse ws conn for remote-ext

utils/staking-miner/Cargo.toml

@@ -5,16 +5,16 @@ authors = ["Parity Technologies <admin@parity.io>"]
 edition = "2018"
 
 [dependencies]
+clap = { version = "3.0", features = ["derive", "env"] }
 codec = { package = "parity-scale-codec", version = "2.0.0" }
-tokio = { version = "1.15", features = ["macros"] }
-log = "0.4.11"
 env_logger = "0.9.0"
-clap = { version = "3.0", features = ["derive", "env"] }
-jsonrpsee = { version = "0.4.1", default-features = false, features = ["ws-client"] }
-serde_json = "1.0"
-serde = "1.0.132"
+jsonrpsee = { version = "0.8", features = ["ws-client"] }
+log = "0.4.11"
 paste = "1.0.6"
+serde = "1.0.132"
+serde_json = "1.0"
 thiserror = "1.0.30"
+tokio = { version = "1.15", features = ["macros", "rt-multi-thread", "sync"] }
 
 remote-externalities = { git = "https://github.com/paritytech/substrate", branch = "master" }
 

utils/staking-miner/README.md

@@ -59,3 +59,10 @@ docker run --rm -it \
     -e URI=wss://your-node:9944 \
     staking-miner dry-run
 ```
+
+### Test locally
+
+1. Modify `EPOCH_DURATION_IN_SLOTS` and `SessionsPerEra` to force an election
+   more often than once per day.
+2. $ polkadot --chain polkadot-dev --tmp --alice --execution Native -lruntime=debug --offchain-worker=Always --ws-port 9999
+3. $ staking-miner --uri ws://localhost:9999 --seed //Alice monitor phrag-mms

utils/staking-miner/src/dry_run.rs

@@ -16,12 +16,11 @@
 
 //! The dry-run command.
 
-use crate::{
-	prelude::*, rpc_helpers::*, signer::Signer, DryRunConfig, Error, SharedConfig, WsClient,
-};
+use crate::{prelude::*, rpc_helpers::*, signer::Signer, DryRunConfig, Error, WsClient};
 use codec::Encode;
 use frame_support::traits::Currency;
 use jsonrpsee::rpc_params;
+use std::sync::Arc;
 
 /// 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>> {
@@ -109,22 +108,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,
+		client: Arc<WsClient>,
 		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(),
+			client.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>(&*client, &signer.account, config.at)
 			.await?
 			.map(|i| i.nonce)
 			.expect("signer account is checked to exist upon startup; it can only die if it \
@@ -136,7 +134,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>(&*client, &mut ext, &raw_solution, bytes.clone()).await;
 
 		let feasibility_result = ext.execute_with(|| {
 			EPM::Pallet::<Runtime>::feasibility_check(raw_solution.clone(), EPM::ElectionCompute::Signed)
@@ -150,7 +148,7 @@ 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 })
+		let outcome = rpc_decode::<sp_runtime::ApplyExtrinsicResult>(&*client, "system_dryRun", rpc_params!{ bytes })
 			.await
 			.map_err::<Error<Runtime>, _>(Into::into)?;
 		log::info!(target: LOG_TARGET, "dry-run outcome is {:?}", outcome);

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, WsClient};
 use codec::Encode;
-use std::io::Write;
+use std::{io::Write, sync::Arc};
 
 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: Arc<WsClient>,
 		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.clone(), config.at, vec![]).await?;
 		let (raw_solution, _witness) = crate::mine_with::<Runtime>(&config.solver, &mut ext, false)?;
 
 		ext.execute_with(|| {

utils/staking-miner/src/main.rs

@@ -45,6 +45,7 @@ use jsonrpsee::ws_client::{WsClient, WsClientBuilder};
 use remote_externalities::{Builder, Mode, OnlineConfig};
 use sp_npos_elections::ExtendedBalance;
 use sp_runtime::{traits::Block as BlockT, DeserializeOwned};
+use std::sync::Arc;
 
 pub(crate) enum AnyRuntime {
 	Polkadot,
@@ -228,7 +229,7 @@ macro_rules! any_runtime_unit {
 #[derive(frame_support::DebugNoBound, thiserror::Error)]
 enum Error<T: EPM::Config> {
 	Io(#[from] std::io::Error),
-	JsonRpsee(#[from] jsonrpsee::types::Error),
+	JsonRpsee(#[from] jsonrpsee::core::Error),
 	RpcHelperError(#[from] rpc_helpers::RpcHelperError),
 	Codec(#[from] codec::Error),
 	Crypto(sp_core::crypto::SecretStringError),
@@ -368,7 +369,7 @@ struct Opt {
 /// Build the Ext at hash with all the data of `ElectionProviderMultiPhase` and any additional
 /// pallets.
 async fn create_election_ext<T: EPM::Config, B: BlockT + DeserializeOwned>(
-	uri: String,
+	client: Arc<WsClient>,
 	at: Option<B::Hash>,
 	additional: Vec<String>,
 ) -> Result<Ext, Error<T>> {
@@ -381,7 +382,7 @@ async fn create_election_ext<T: EPM::Config, B: BlockT + DeserializeOwned>(
 	pallets.extend(additional);
 	Builder::<B>::new()
 		.mode(Mode::Online(OnlineConfig {
-			transport: uri.into(),
+			transport: client.into(),
 			at,
 			pallets,
 			..Default::default()
@@ -531,7 +532,7 @@ async fn main() {
 			.build(&shared.uri)
 			.await;
 		match maybe_client {
-			Ok(client) => break client,
+			Ok(client) => break Arc::new(client),
 			Err(why) => {
 				log::warn!(
 					target: LOG_TARGET,
@@ -602,15 +603,15 @@ async fn main() {
 
 	let outcome = any_runtime! {
 		match command.clone() {
-			Command::Monitor(c) => monitor_cmd(&client, shared, c, signer_account).await
+			Command::Monitor(c) => monitor_cmd(client, c, signer_account).await
 				.map_err(|e| {
 					log::error!(target: LOG_TARGET, "Monitor error: {:?}", e);
 				}),
-			Command::DryRun(c) => dry_run_cmd(&client, shared, c, signer_account).await
+			Command::DryRun(c) => dry_run_cmd(client, c, signer_account).await
 				.map_err(|e| {
 					log::error!(target: LOG_TARGET, "DryRun error: {:?}", e);
 				}),
-			Command::EmergencySolution(c) => emergency_solution_cmd(shared.clone(), c).await
+			Command::EmergencySolution(c) => emergency_solution_cmd(client, c).await
 				.map_err(|e| {
 					log::error!(target: LOG_TARGET, "EmergencySolution error: {:?}", e);
 				}),