CLI: Consolidate offline arg declarations (#7979)

automerge

cli/src/cli.rs

@@ -2,6 +2,7 @@ use crate::{
     cluster_query::*,
     display::{println_name_value, println_signers},
     nonce::{self, *},
+    offline::*,
     stake::*,
     storage::*,
     validator_info::*,
@@ -599,9 +600,9 @@ pub fn parse_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Box<dyn
             let timestamp_pubkey = value_of(&matches, "timestamp_pubkey");
             let witnesses = values_of(&matches, "witness");
             let cancelable = matches.is_present("cancelable");
-            let sign_only = matches.is_present("sign_only");
-            let signers = pubkeys_sigs_of(&matches, "signer");
-            let blockhash = value_of(&matches, "blockhash");
+            let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+            let signers = pubkeys_sigs_of(&matches, SIGNER_ARG.name);
+            let blockhash = value_of(&matches, BLOCKHASH_ARG.name);
             let nonce_account = pubkey_of(&matches, NONCE_ARG.name);
             let nonce_authority = if matches.is_present(NONCE_AUTHORITY_ARG.name) {
                 Some(SigningAuthority::new_from_matches(
@@ -1973,31 +1974,9 @@ pub fn app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, '
                         .long("cancelable")
                         .takes_value(false),
                 )
-                .arg(
-                    Arg::with_name("sign_only")
-                        .long("sign-only")
-                        .takes_value(false)
-                        .help("Sign the transaction offline"),
-                )
+                .offline_args()
                 .arg(nonce_arg())
-                .arg(nonce_authority_arg())
-                .arg(
-                    Arg::with_name("signer")
-                        .long("signer")
-                        .value_name("PUBKEY=BASE58_SIG")
-                        .takes_value(true)
-                        .validator(is_pubkey_sig)
-                        .multiple(true)
-                        .help("Provide a public-key/signature pair for the transaction"),
-                )
-                .arg(
-                    Arg::with_name("blockhash")
-                        .long("blockhash")
-                        .value_name("BLOCKHASH")
-                        .takes_value(true)
-                        .validator(is_hash)
-                        .help("Use the supplied blockhash"),
-                ),
+                .arg(nonce_authority_arg()),
         )
         .subcommand(
             SubCommand::with_name("send-signature")

cli/src/lib.rs

@@ -6,6 +6,7 @@ pub mod cluster_query;
 pub mod config;
 pub mod display;
 pub mod nonce;
+pub mod offline;
 pub mod stake;
 pub mod storage;
 pub mod validator_info;

cli/src/nonce.rs

@@ -3,6 +3,7 @@ use crate::cli::{
     log_instruction_custom_error, required_lamports_from, CliCommand, CliCommandInfo, CliConfig,
     CliError, ProcessResult, SigningAuthority,
 };
+use crate::offline::BLOCKHASH_ARG;
 use clap::{App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{input_parsers::*, input_validators::*, ArgConstant};
 use solana_client::rpc_client::RpcClient;
@@ -55,7 +56,7 @@ pub fn nonce_arg<'a, 'b>() -> Arg<'a, 'b> {
         .long(NONCE_ARG.long)
         .takes_value(true)
         .value_name("PUBKEY")
-        .requires("blockhash")
+        .requires(BLOCKHASH_ARG.name)
         .validator(is_pubkey)
         .help(NONCE_ARG.help)
 }

cli/src/offline.rs

@@ -0,0 +1,61 @@
+use clap::{App, Arg};
+use solana_clap_utils::{
+    input_validators::{is_hash, is_pubkey_sig},
+    ArgConstant,
+};
+
+pub const BLOCKHASH_ARG: ArgConstant<'static> = ArgConstant {
+    name: "blockhash",
+    long: "blockhash",
+    help: "Use the supplied blockhash",
+};
+
+pub const SIGN_ONLY_ARG: ArgConstant<'static> = ArgConstant {
+    name: "sign_only",
+    long: "sign-only",
+    help: "Sign the transaction offline",
+};
+
+pub const SIGNER_ARG: ArgConstant<'static> = ArgConstant {
+    name: "signer",
+    long: "signer",
+    help: "Provid a public-key/signature pair for the transaction",
+};
+
+fn blockhash_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(BLOCKHASH_ARG.name)
+        .long(BLOCKHASH_ARG.long)
+        .takes_value(true)
+        .value_name("BLOCKHASH")
+        .validator(is_hash)
+        .help(BLOCKHASH_ARG.help)
+}
+
+fn sign_only_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(SIGN_ONLY_ARG.name)
+        .long(SIGN_ONLY_ARG.long)
+        .takes_value(false)
+        .help(SIGN_ONLY_ARG.help)
+}
+
+fn signer_arg<'a, 'b>() -> Arg<'a, 'b> {
+    Arg::with_name(SIGNER_ARG.name)
+        .long(SIGNER_ARG.long)
+        .takes_value(true)
+        .value_name("BASE58_PUBKEY=BASE58_SIG")
+        .validator(is_pubkey_sig)
+        .multiple(true)
+        .help(SIGNER_ARG.help)
+}
+
+pub trait OfflineArgs {
+    fn offline_args(self) -> Self;
+}
+
+impl OfflineArgs for App<'_, '_> {
+    fn offline_args(self) -> Self {
+        self.arg(blockhash_arg())
+            .arg(sign_only_arg())
+            .arg(signer_arg())
+    }
+}

cli/src/stake.rs

@@ -6,6 +6,7 @@ use crate::{
         CliConfig, CliError, ProcessResult, SigningAuthority,
     },
     nonce::{check_nonce_account, nonce_arg, NONCE_ARG, NONCE_AUTHORITY_ARG},
+    offline::*,
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
 use console::style;
@@ -172,29 +173,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .help("The vote account to which the stake will be delegated")
                 )
                 .arg(stake_authority_arg())
-                .arg(
-                    Arg::with_name("sign_only")
-                        .long("sign-only")
-                        .takes_value(false)
-                        .help("Sign the transaction offline"),
-                )
-                .arg(
-                    Arg::with_name("signer")
-                        .long("signer")
-                        .value_name("PUBKEY=BASE58_SIG")
-                        .takes_value(true)
-                        .validator(is_pubkey_sig)
-                        .multiple(true)
-                        .help("Provide a public-key/signature pair for the transaction"),
-                )
-                .arg(
-                    Arg::with_name("blockhash")
-                        .long("blockhash")
-                        .value_name("BLOCKHASH")
-                        .takes_value(true)
-                        .validator(is_hash)
-                        .help("Use the supplied blockhash"),
-                )
+                .offline_args()
                 .arg(nonce_arg())
                 .arg(nonce_authority_arg())
         )
@@ -220,29 +199,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .help("New authorized staker")
                 )
                 .arg(stake_authority_arg())
-                .arg(
-                    Arg::with_name("sign_only")
-                        .long("sign-only")
-                        .takes_value(false)
-                        .help("Sign the transaction offline"),
-                )
-                .arg(
-                    Arg::with_name("signer")
-                        .long("signer")
-                        .value_name("PUBKEY=BASE58_SIG")
-                        .takes_value(true)
-                        .validator(is_pubkey_sig)
-                        .multiple(true)
-                        .help("Provide a public-key/signature pair for the transaction"),
-                )
-                .arg(
-                    Arg::with_name("blockhash")
-                        .long("blockhash")
-                        .value_name("BLOCKHASH")
-                        .takes_value(true)
-                        .validator(is_hash)
-                        .help("Use the supplied blockhash"),
-                )
+                .offline_args()
                 .arg(nonce_arg())
                 .arg(nonce_authority_arg())
         )
@@ -268,29 +225,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .help("New authorized withdrawer")
                 )
                 .arg(withdraw_authority_arg())
-                .arg(
-                    Arg::with_name("sign_only")
-                        .long("sign-only")
-                        .takes_value(false)
-                        .help("Sign the transaction offline"),
-                )
-                .arg(
-                    Arg::with_name("signer")
-                        .long("signer")
-                        .value_name("PUBKEY=BASE58_SIG")
-                        .takes_value(true)
-                        .validator(is_pubkey_sig)
-                        .multiple(true)
-                        .help("Provide a public-key/signature pair for the transaction"),
-                )
-                .arg(
-                    Arg::with_name("blockhash")
-                        .long("blockhash")
-                        .value_name("BLOCKHASH")
-                        .takes_value(true)
-                        .validator(is_hash)
-                        .help("Use the supplied blockhash"),
-                )
+                .offline_args()
                 .arg(nonce_arg())
                 .arg(nonce_authority_arg())
         )
@@ -306,29 +241,7 @@ impl StakeSubCommands for App<'_, '_> {
                         .help("Stake account to be deactivated.")
                 )
                 .arg(stake_authority_arg())
-                .arg(
-                    Arg::with_name("sign_only")
-                        .long("sign-only")
-                        .takes_value(false)
-                        .help("Sign the transaction offline"),
-                )
-                .arg(
-                    Arg::with_name("signer")
-                        .long("signer")
-                        .value_name("PUBKEY=BASE58_SIG")
-                        .takes_value(true)
-                        .validator(is_pubkey_sig)
-                        .multiple(true)
-                        .help("Provide a public-key/signature pair for the transaction"),
-                )
-                .arg(
-                    Arg::with_name("blockhash")
-                        .long("blockhash")
-                        .value_name("BLOCKHASH")
-                        .takes_value(true)
-                        .validator(is_hash)
-                        .help("Use the supplied blockhash"),
-                )
+                .offline_args()
                 .arg(nonce_arg())
                 .arg(nonce_authority_arg())
         )
@@ -437,9 +350,9 @@ pub fn parse_stake_delegate_stake(matches: &ArgMatches<'_>) -> Result<CliCommand
     let stake_account_pubkey = pubkey_of(matches, "stake_account_pubkey").unwrap();
     let vote_account_pubkey = pubkey_of(matches, "vote_account_pubkey").unwrap();
     let force = matches.is_present("force");
-    let sign_only = matches.is_present("sign_only");
-    let signers = pubkeys_sigs_of(&matches, "signer");
-    let blockhash = value_of(matches, "blockhash");
+    let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+    let signers = pubkeys_sigs_of(&matches, SIGNER_ARG.name);
+    let blockhash = value_of(matches, BLOCKHASH_ARG.name);
     let require_keypair = signers.is_none();
     let nonce_account = pubkey_of(&matches, NONCE_ARG.name);
     let stake_authority = if matches.is_present(STAKE_AUTHORITY_ARG.name) {
@@ -487,8 +400,8 @@ pub fn parse_stake_authorize(
         StakeAuthorize::Staker => STAKE_AUTHORITY_ARG.name,
         StakeAuthorize::Withdrawer => WITHDRAW_AUTHORITY_ARG.name,
     };
-    let sign_only = matches.is_present("sign_only");
-    let signers = pubkeys_sigs_of(&matches, "signer");
+    let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+    let signers = pubkeys_sigs_of(&matches, SIGNER_ARG.name);
     let authority = if matches.is_present(authority_flag) {
         Some(SigningAuthority::new_from_matches(
             &matches,
@@ -498,7 +411,7 @@ pub fn parse_stake_authorize(
     } else {
         None
     };
-    let blockhash = value_of(matches, "blockhash");
+    let blockhash = value_of(matches, BLOCKHASH_ARG.name);
     let nonce_account = pubkey_of(&matches, NONCE_ARG.name);
     let nonce_authority = if matches.is_present(NONCE_AUTHORITY_ARG.name) {
         Some(SigningAuthority::new_from_matches(
@@ -528,9 +441,9 @@ pub fn parse_stake_authorize(
 
 pub fn parse_stake_deactivate_stake(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
     let stake_account_pubkey = pubkey_of(matches, "stake_account_pubkey").unwrap();
-    let sign_only = matches.is_present("sign_only");
-    let signers = pubkeys_sigs_of(&matches, "signer");
-    let blockhash = value_of(matches, "blockhash");
+    let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+    let signers = pubkeys_sigs_of(&matches, SIGNER_ARG.name);
+    let blockhash = value_of(matches, BLOCKHASH_ARG.name);
     let require_keypair = signers.is_none();
     let nonce_account = pubkey_of(&matches, NONCE_ARG.name);
     let stake_authority = if matches.is_present(STAKE_AUTHORITY_ARG.name) {