gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Tame wallet manager better (#9567) (#9575)

Browse Source 
automerge
This commit is contained in:
mergify[bot]
2020-04-18 13:37:40 -07:00
committed by GitHub
parent 6a5f67f78c
commit 8f9f11e37f
12 changed files with 214 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
clap-utils/src/input_parsers.rs
View File

@@ -116,7 +116,7 @@ pub fn pubkeys_sigs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<(Pubk
pub fn signer_of( pub fn signer_of(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
name: &str, name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<(Option<Box<dyn Signer>>, Option<Pubkey>), Box<dyn std::error::Error>> { ) -> Result<(Option<Box<dyn Signer>>, Option<Pubkey>), Box<dyn std::error::Error>> {
if let Some(location) = matches.value_of(name) { if let Some(location) = matches.value_of(name) {
let signer = signer_from_path(matches, location, name, wallet_manager)?; let signer = signer_from_path(matches, location, name, wallet_manager)?;
@@ -130,7 +130,7 @@ pub fn signer_of(
pub fn pubkey_of_signer( pub fn pubkey_of_signer(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
name: &str, name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Option<Pubkey>, Box<dyn std::error::Error>> { ) -> Result<Option<Pubkey>, Box<dyn std::error::Error>> {
if let Some(location) = matches.value_of(name) { if let Some(location) = matches.value_of(name) {
Ok(Some(pubkey_from_path( Ok(Some(pubkey_from_path(
@@ -147,7 +147,7 @@ pub fn pubkey_of_signer(
pub fn pubkeys_of_multiple_signers( pub fn pubkeys_of_multiple_signers(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
name: &str, name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Option<Vec<Pubkey>>, Box<dyn std::error::Error>> { ) -> Result<Option<Vec<Pubkey>>, Box<dyn std::error::Error>> {
if let Some(pubkey_matches) = matches.values_of(name) { if let Some(pubkey_matches) = matches.values_of(name) {
let mut pubkeys: Vec<Pubkey> = vec![]; let mut pubkeys: Vec<Pubkey> = vec![];
@@ -163,7 +163,7 @@ pub fn pubkeys_of_multiple_signers(
pub fn resolve_signer( pub fn resolve_signer(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
name: &str, name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Option<String>, Box<dyn std::error::Error>> { ) -> Result<Option<String>, Box<dyn std::error::Error>> {
Ok(resolve_signer_from_path( Ok(resolve_signer_from_path(
matches, matches,

37
clap-utils/src/keypair.rs
View File

@@ -8,7 +8,7 @@ use clap::ArgMatches;
use rpassword::prompt_password_stderr; use rpassword::prompt_password_stderr;
use solana_remote_wallet::{ use solana_remote_wallet::{
remote_keypair::generate_remote_keypair, remote_keypair::generate_remote_keypair,
remote_wallet::{RemoteWalletError, RemoteWalletManager}, remote_wallet::{maybe_wallet_manager, RemoteWalletError, RemoteWalletManager},
}; };
use solana_sdk::{ use solana_sdk::{
pubkey::Pubkey, pubkey::Pubkey,
@@ -47,13 +47,6 @@ pub fn parse_keypair_path(path: &str) -> KeypairUrl {
} }
} }
pub fn check_for_usb<S>(mut items: impl Iterator<Item = S>) -> bool
where
S: Into<String>,
{
items.any(|arg| matches!(parse_keypair_path(&arg.into()), KeypairUrl::Usb(_)))
}
pub fn presigner_from_pubkey_sigs( pub fn presigner_from_pubkey_sigs(
pubkey: &Pubkey, pubkey: &Pubkey,
signers: &[(Pubkey, Signature)], signers: &[(Pubkey, Signature)],
@@ -71,7 +64,7 @@ pub fn signer_from_path(
matches: &ArgMatches, matches: &ArgMatches,
path: &str, path: &str,
keypair_name: &str, keypair_name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Box<dyn Signer>, Box<dyn error::Error>> { ) -> Result<Box<dyn Signer>, Box<dyn error::Error>> {
match parse_keypair_path(path) { match parse_keypair_path(path) {
KeypairUrl::Ask => { KeypairUrl::Ask => {
@@ -95,6 +88,9 @@ pub fn signer_from_path(
Ok(Box::new(read_keypair(&mut stdin)?)) Ok(Box::new(read_keypair(&mut stdin)?))
} }
KeypairUrl::Usb(path) => { KeypairUrl::Usb(path) => {
if wallet_manager.is_none() {
*wallet_manager = maybe_wallet_manager()?;
}
if let Some(wallet_manager) = wallet_manager { if let Some(wallet_manager) = wallet_manager {
Ok(Box::new(generate_remote_keypair( Ok(Box::new(generate_remote_keypair(
path, path,
@@ -129,7 +125,7 @@ pub fn pubkey_from_path(
matches: &ArgMatches, matches: &ArgMatches,
path: &str, path: &str,
keypair_name: &str, keypair_name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Pubkey, Box<dyn error::Error>> { ) -> Result<Pubkey, Box<dyn error::Error>> {
match parse_keypair_path(path) { match parse_keypair_path(path) {
KeypairUrl::Pubkey(pubkey) => Ok(pubkey), KeypairUrl::Pubkey(pubkey) => Ok(pubkey),
@@ -141,7 +137,7 @@ pub fn resolve_signer_from_path(
matches: &ArgMatches, matches: &ArgMatches,
path: &str, path: &str,
keypair_name: &str, keypair_name: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Option<String>, Box<dyn error::Error>> { ) -> Result<Option<String>, Box<dyn error::Error>> {
match parse_keypair_path(path) { match parse_keypair_path(path) {
KeypairUrl::Ask => { KeypairUrl::Ask => {
@@ -165,6 +161,9 @@ pub fn resolve_signer_from_path(
read_keypair(&mut stdin).map(|_| None) read_keypair(&mut stdin).map(|_| None)
} }
KeypairUrl::Usb(path) => { KeypairUrl::Usb(path) => {
if wallet_manager.is_none() {
*wallet_manager = maybe_wallet_manager()?;
}
if let Some(wallet_manager) = wallet_manager { if let Some(wallet_manager) = wallet_manager {
let path = generate_remote_keypair( let path = generate_remote_keypair(
path, path,
@@ -263,20 +262,4 @@ mod tests {
sanitize_seed_phrase(seed_phrase) sanitize_seed_phrase(seed_phrase)
); );
} }
#[test]
fn test_check_for_usb() {
let args: Vec<&str> = vec![];
assert_eq!(check_for_usb(args.into_iter()), false);
let args = vec!["usb://"];
assert_eq!(check_for_usb(args.into_iter()), true);
let args = vec!["other"];
assert_eq!(check_for_usb(args.into_iter()), false);
let args = vec!["other", "usb://", "another"];
assert_eq!(check_for_usb(args.into_iter()), true);
let args = vec!["other", "another"];
assert_eq!(check_for_usb(args.into_iter()), false);
let args = vec!["usb://", "usb://"];
assert_eq!(check_for_usb(args.into_iter()), true);
}
} }

78
cli/src/cli.rs
View File

@@ -86,7 +86,7 @@ pub(crate) fn generate_unique_signers(
bulk_signers: Vec<Option<Box<dyn Signer>>>, bulk_signers: Vec<Option<Box<dyn Signer>>>,
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliSignerInfo, Box<dyn error::Error>> { ) -> Result<CliSignerInfo, Box<dyn error::Error>> {
let mut unique_signers = vec![]; let mut unique_signers = vec![];
@@ -574,7 +574,7 @@ impl Default for CliConfig<'_> {
pub fn parse_command( pub fn parse_command(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, Box<dyn error::Error>> { ) -> Result<CliCommandInfo, Box<dyn error::Error>> {
let response = match matches.subcommand() { let response = match matches.subcommand() {
// Cluster Query Commands // Cluster Query Commands
@@ -1054,7 +1054,7 @@ pub fn return_signers(tx: &Transaction) -> ProcessResult {
pub fn parse_create_address_with_seed( pub fn parse_create_address_with_seed(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let from_pubkey = pubkey_of_signer(matches, "from", wallet_manager)?; let from_pubkey = pubkey_of_signer(matches, "from", wallet_manager)?;
let signers = if from_pubkey.is_some() { let signers = if from_pubkey.is_some() {
@@ -2651,11 +2651,11 @@ mod tests {
write_keypair_file(&default_keypair, &default_keypair_file).unwrap(); write_keypair_file(&default_keypair, &default_keypair_file).unwrap();
let signer_info = let signer_info =
generate_unique_signers(vec![], &matches, &default_keypair_file, None).unwrap(); generate_unique_signers(vec![], &matches, &default_keypair_file, &mut None).unwrap();
assert_eq!(signer_info.signers.len(), 0); assert_eq!(signer_info.signers.len(), 0);
let signer_info = let signer_info =
generate_unique_signers(vec![None, None], &matches, &default_keypair_file, None) generate_unique_signers(vec![None, None], &matches, &default_keypair_file, &mut None)
.unwrap(); .unwrap();
assert_eq!(signer_info.signers.len(), 1); assert_eq!(signer_info.signers.len(), 1);
assert_eq!(signer_info.index_of(None), Some(0)); assert_eq!(signer_info.index_of(None), Some(0));
@@ -2667,7 +2667,7 @@ mod tests {
let keypair0_clone_pubkey = keypair0.pubkey(); let keypair0_clone_pubkey = keypair0.pubkey();
let signers = vec![None, Some(keypair0.into()), Some(keypair0_clone.into())]; let signers = vec![None, Some(keypair0.into()), Some(keypair0_clone.into())];
let signer_info = let signer_info =
generate_unique_signers(signers, &matches, &default_keypair_file, None).unwrap(); generate_unique_signers(signers, &matches, &default_keypair_file, &mut None).unwrap();
assert_eq!(signer_info.signers.len(), 2); assert_eq!(signer_info.signers.len(), 2);
assert_eq!(signer_info.index_of(None), Some(0)); assert_eq!(signer_info.index_of(None), Some(0));
assert_eq!(signer_info.index_of(Some(keypair0_pubkey)), Some(1)); assert_eq!(signer_info.index_of(Some(keypair0_pubkey)), Some(1));
@@ -2678,7 +2678,7 @@ mod tests {
let keypair0_clone = keypair_from_seed(&[1u8; 32]).unwrap(); let keypair0_clone = keypair_from_seed(&[1u8; 32]).unwrap();
let signers = vec![Some(keypair0.into()), Some(keypair0_clone.into())]; let signers = vec![Some(keypair0.into()), Some(keypair0_clone.into())];
let signer_info = let signer_info =
generate_unique_signers(signers, &matches, &default_keypair_file, None).unwrap(); generate_unique_signers(signers, &matches, &default_keypair_file, &mut None).unwrap();
assert_eq!(signer_info.signers.len(), 1); assert_eq!(signer_info.signers.len(), 1);
assert_eq!(signer_info.index_of(Some(keypair0_pubkey)), Some(0)); assert_eq!(signer_info.index_of(Some(keypair0_pubkey)), Some(0));
@@ -2699,7 +2699,7 @@ mod tests {
Some(keypair1.into()), Some(keypair1.into()),
]; ];
let signer_info = let signer_info =
generate_unique_signers(signers, &matches, &default_keypair_file, None).unwrap(); generate_unique_signers(signers, &matches, &default_keypair_file, &mut None).unwrap();
assert_eq!(signer_info.signers.len(), 2); assert_eq!(signer_info.signers.len(), 2);
assert_eq!(signer_info.index_of(Some(keypair0_pubkey)), Some(0)); assert_eq!(signer_info.index_of(Some(keypair0_pubkey)), Some(0));
assert_eq!(signer_info.index_of(Some(keypair1_pubkey)), Some(1)); assert_eq!(signer_info.index_of(Some(keypair1_pubkey)), Some(1));
@@ -2725,7 +2725,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "airdrop", "50", &pubkey_string]); .get_matches_from(vec!["test", "airdrop", "50", &pubkey_string]);
assert_eq!( assert_eq!(
parse_command(&test_airdrop, "", None).unwrap(), parse_command(&test_airdrop, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Airdrop { command: CliCommand::Airdrop {
faucet_host: None, faucet_host: None,
@@ -2748,7 +2748,7 @@ mod tests {
&keypair.pubkey().to_string(), &keypair.pubkey().to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_balance, "", None).unwrap(), parse_command(&test_balance, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Balance { command: CliCommand::Balance {
pubkey: Some(keypair.pubkey()), pubkey: Some(keypair.pubkey()),
@@ -2764,7 +2764,7 @@ mod tests {
"--lamports", "--lamports",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_balance, "", None).unwrap(), parse_command(&test_balance, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Balance { command: CliCommand::Balance {
pubkey: Some(keypair.pubkey()), pubkey: Some(keypair.pubkey()),
@@ -2778,7 +2778,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "balance", "--lamports"]); .get_matches_from(vec!["test", "balance", "--lamports"]);
assert_eq!( assert_eq!(
parse_command(&test_balance, &keypair_file, None).unwrap(), parse_command(&test_balance, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Balance { command: CliCommand::Balance {
pubkey: None, pubkey: None,
@@ -2794,7 +2794,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "cancel", &pubkey_string]); .get_matches_from(vec!["test", "cancel", &pubkey_string]);
assert_eq!( assert_eq!(
parse_command(&test_cancel, &keypair_file, None).unwrap(), parse_command(&test_cancel, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Cancel(pubkey), command: CliCommand::Cancel(pubkey),
signers: vec![read_keypair_file(&keypair_file).unwrap().into()], signers: vec![read_keypair_file(&keypair_file).unwrap().into()],
@@ -2809,7 +2809,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "confirm", &signature_string]); .get_matches_from(vec!["test", "confirm", &signature_string]);
assert_eq!( assert_eq!(
parse_command(&test_confirm, "", None).unwrap(), parse_command(&test_confirm, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Confirm(signature), command: CliCommand::Confirm(signature),
signers: vec![], signers: vec![],
@@ -2818,7 +2818,7 @@ mod tests {
let test_bad_signature = test_commands let test_bad_signature = test_commands
.clone() .clone()
.get_matches_from(vec!["test", "confirm", "deadbeef"]); .get_matches_from(vec!["test", "confirm", "deadbeef"]);
assert!(parse_command(&test_bad_signature, "", None).is_err()); assert!(parse_command(&test_bad_signature, "", &mut None).is_err());
// Test CreateAddressWithSeed // Test CreateAddressWithSeed
let from_pubkey = Some(Pubkey::new_rand()); let from_pubkey = Some(Pubkey::new_rand());
@@ -2838,7 +2838,7 @@ mod tests {
&from_str, &from_str,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_address_with_seed, "", None).unwrap(), parse_command(&test_create_address_with_seed, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateAddressWithSeed { command: CliCommand::CreateAddressWithSeed {
from_pubkey, from_pubkey,
@@ -2856,7 +2856,7 @@ mod tests {
"STAKE", "STAKE",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_address_with_seed, &keypair_file, None).unwrap(), parse_command(&test_create_address_with_seed, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateAddressWithSeed { command: CliCommand::CreateAddressWithSeed {
from_pubkey: None, from_pubkey: None,
@@ -2873,7 +2873,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "deploy", "/Users/test/program.o"]); .get_matches_from(vec!["test", "deploy", "/Users/test/program.o"]);
assert_eq!( assert_eq!(
parse_command(&test_deploy, &keypair_file, None).unwrap(), parse_command(&test_deploy, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Deploy("/Users/test/program.o".to_string()), command: CliCommand::Deploy("/Users/test/program.o".to_string()),
signers: vec![read_keypair_file(&keypair_file).unwrap().into()], signers: vec![read_keypair_file(&keypair_file).unwrap().into()],
@@ -2886,7 +2886,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "resolve-signer", &keypair_file]); .get_matches_from(vec!["test", "resolve-signer", &keypair_file]);
assert_eq!( assert_eq!(
parse_command(&test_resolve_signer, "", None).unwrap(), parse_command(&test_resolve_signer, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::ResolveSigner(Some(keypair_file.clone())), command: CliCommand::ResolveSigner(Some(keypair_file.clone())),
signers: vec![], signers: vec![],
@@ -2898,7 +2898,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "resolve-signer", &pubkey_string]); .get_matches_from(vec!["test", "resolve-signer", &pubkey_string]);
assert_eq!( assert_eq!(
parse_command(&test_resolve_signer, "", None).unwrap(), parse_command(&test_resolve_signer, "", &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::ResolveSigner(Some(pubkey.to_string())), command: CliCommand::ResolveSigner(Some(pubkey.to_string())),
signers: vec![], signers: vec![],
@@ -2911,7 +2911,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "pay", &pubkey_string, "50"]); .get_matches_from(vec!["test", "pay", &pubkey_string, "50"]);
assert_eq!( assert_eq!(
parse_command(&test_pay, &keypair_file, None).unwrap(), parse_command(&test_pay, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -2934,7 +2934,7 @@ mod tests {
&witness1_string, &witness1_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay_multiple_witnesses, &keypair_file, None).unwrap(), parse_command(&test_pay_multiple_witnesses, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -2954,7 +2954,7 @@ mod tests {
&witness0_string, &witness0_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay_single_witness, &keypair_file, None).unwrap(), parse_command(&test_pay_single_witness, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -2978,7 +2978,7 @@ mod tests {
&witness0_string, &witness0_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay_timestamp, &keypair_file, None).unwrap(), parse_command(&test_pay_timestamp, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3004,7 +3004,7 @@ mod tests {
"--sign-only", "--sign-only",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay, &keypair_file, None).unwrap(), parse_command(&test_pay, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3027,7 +3027,7 @@ mod tests {
&blockhash_string, &blockhash_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay, &keypair_file, None).unwrap(), parse_command(&test_pay, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3056,7 +3056,7 @@ mod tests {
&pubkey_string, &pubkey_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay, &keypair_file, None).unwrap(), parse_command(&test_pay, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3089,7 +3089,7 @@ mod tests {
&keypair_file, &keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay, &keypair_file, None).unwrap(), parse_command(&test_pay, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3127,7 +3127,7 @@ mod tests {
&signer_arg, &signer_arg,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay, &keypair_file, None).unwrap(), parse_command(&test_pay, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3165,7 +3165,7 @@ mod tests {
"--signer", "--signer",
&signer_arg, &signer_arg,
]); ]);
assert!(parse_command(&test_pay, &keypair_file, None).is_err()); assert!(parse_command(&test_pay, &keypair_file, &mut None).is_err());
// Test Send-Signature Subcommand // Test Send-Signature Subcommand
let test_send_signature = test_commands.clone().get_matches_from(vec![ let test_send_signature = test_commands.clone().get_matches_from(vec![
@@ -3175,7 +3175,7 @@ mod tests {
&pubkey_string, &pubkey_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_send_signature, &keypair_file, None).unwrap(), parse_command(&test_send_signature, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Witness(pubkey, pubkey), command: CliCommand::Witness(pubkey, pubkey),
signers: vec![read_keypair_file(&keypair_file).unwrap().into()], signers: vec![read_keypair_file(&keypair_file).unwrap().into()],
@@ -3196,7 +3196,7 @@ mod tests {
&witness1_string, &witness1_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_pay_multiple_witnesses, &keypair_file, None).unwrap(), parse_command(&test_pay_multiple_witnesses, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Pay(PayCommand { command: CliCommand::Pay(PayCommand {
lamports: 50_000_000_000, lamports: 50_000_000_000,
@@ -3220,7 +3220,7 @@ mod tests {
"2018-09-19T17:30:59", "2018-09-19T17:30:59",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_send_timestamp, &keypair_file, None).unwrap(), parse_command(&test_send_timestamp, &keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::TimeElapsed(pubkey, pubkey, dt), command: CliCommand::TimeElapsed(pubkey, pubkey, dt),
signers: vec![read_keypair_file(&keypair_file).unwrap().into()], signers: vec![read_keypair_file(&keypair_file).unwrap().into()],
@@ -3234,7 +3234,7 @@ mod tests {
"--date", "--date",
"20180919T17:30:59", "20180919T17:30:59",
]); ]);
assert!(parse_command(&test_bad_timestamp, &keypair_file, None).is_err()); assert!(parse_command(&test_bad_timestamp, &keypair_file, &mut None).is_err());
} }
#[test] #[test]
@@ -3609,7 +3609,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "transfer", &to_string, "42"]); .get_matches_from(vec!["test", "transfer", &to_string, "42"]);
assert_eq!( assert_eq!(
parse_command(&test_transfer, &default_keypair_file, None).unwrap(), parse_command(&test_transfer, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Transfer { command: CliCommand::Transfer {
lamports: 42_000_000_000, lamports: 42_000_000_000,
@@ -3635,7 +3635,7 @@ mod tests {
"42", "42",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_transfer, &default_keypair_file, None).unwrap(), parse_command(&test_transfer, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Transfer { command: CliCommand::Transfer {
lamports: 42_000_000_000, lamports: 42_000_000_000,
@@ -3665,7 +3665,7 @@ mod tests {
"--sign-only", "--sign-only",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_transfer, &default_keypair_file, None).unwrap(), parse_command(&test_transfer, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Transfer { command: CliCommand::Transfer {
lamports: 42_000_000_000, lamports: 42_000_000_000,
@@ -3700,7 +3700,7 @@ mod tests {
&blockhash_string, &blockhash_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_transfer, &default_keypair_file, None).unwrap(), parse_command(&test_transfer, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Transfer { command: CliCommand::Transfer {
lamports: 42_000_000_000, lamports: 42_000_000_000,
@@ -3739,7 +3739,7 @@ mod tests {
&nonce_authority_file, &nonce_authority_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_transfer, &default_keypair_file, None).unwrap(), parse_command(&test_transfer, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Transfer { command: CliCommand::Transfer {
lamports: 42_000_000_000, lamports: 42_000_000_000,

26
cli/src/cluster_query.rs
View File

@@ -282,7 +282,7 @@ impl ClusterQuerySubCommands for App<'_, '_> {
pub fn parse_catchup( pub fn parse_catchup(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let node_pubkey = pubkey_of_signer(matches, "node_pubkey", wallet_manager)?.unwrap(); let node_pubkey = pubkey_of_signer(matches, "node_pubkey", wallet_manager)?.unwrap();
let node_json_rpc_url = value_t!(matches, "node_json_rpc_url", String).ok(); let node_json_rpc_url = value_t!(matches, "node_json_rpc_url", String).ok();
@@ -306,7 +306,7 @@ pub fn parse_catchup(
pub fn parse_cluster_ping( pub fn parse_cluster_ping(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let lamports = value_t_or_exit!(matches, "lamports", u64); let lamports = value_t_or_exit!(matches, "lamports", u64);
let interval = Duration::from_secs(value_t_or_exit!(matches, "interval", u64)); let interval = Duration::from_secs(value_t_or_exit!(matches, "interval", u64));
@@ -408,7 +408,7 @@ pub fn parse_get_transaction_count(matches: &ArgMatches<'_>) -> Result<CliComman
pub fn parse_show_stakes( pub fn parse_show_stakes(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let use_lamports_unit = matches.is_present("lamports"); let use_lamports_unit = matches.is_present("lamports");
let vote_account_pubkeys = let vote_account_pubkeys =
@@ -1197,7 +1197,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "cluster-version"]); .get_matches_from(vec!["test", "cluster-version"]);
assert_eq!( assert_eq!(
parse_command(&test_cluster_version, &default_keypair_file, None).unwrap(), parse_command(&test_cluster_version, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::ClusterVersion, command: CliCommand::ClusterVersion,
signers: vec![], signers: vec![],
@@ -1206,7 +1206,7 @@ mod tests {
let test_fees = test_commands.clone().get_matches_from(vec!["test", "fees"]); let test_fees = test_commands.clone().get_matches_from(vec!["test", "fees"]);
assert_eq!( assert_eq!(
parse_command(&test_fees, &default_keypair_file, None).unwrap(), parse_command(&test_fees, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Fees, command: CliCommand::Fees,
signers: vec![], signers: vec![],
@@ -1219,7 +1219,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "block-time", &slot.to_string()]); .get_matches_from(vec!["test", "block-time", &slot.to_string()]);
assert_eq!( assert_eq!(
parse_command(&test_get_block_time, &default_keypair_file, None).unwrap(), parse_command(&test_get_block_time, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetBlockTime { slot }, command: CliCommand::GetBlockTime { slot },
signers: vec![], signers: vec![],
@@ -1230,7 +1230,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "epoch-info"]); .get_matches_from(vec!["test", "epoch-info"]);
assert_eq!( assert_eq!(
parse_command(&test_get_epoch_info, &default_keypair_file, None).unwrap(), parse_command(&test_get_epoch_info, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetEpochInfo { command: CliCommand::GetEpochInfo {
commitment_config: CommitmentConfig::recent(), commitment_config: CommitmentConfig::recent(),
@@ -1243,7 +1243,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "genesis-hash"]); .get_matches_from(vec!["test", "genesis-hash"]);
assert_eq!( assert_eq!(
parse_command(&test_get_genesis_hash, &default_keypair_file, None).unwrap(), parse_command(&test_get_genesis_hash, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetGenesisHash, command: CliCommand::GetGenesisHash,
signers: vec![], signers: vec![],
@@ -1252,7 +1252,7 @@ mod tests {
let test_get_slot = test_commands.clone().get_matches_from(vec!["test", "slot"]); let test_get_slot = test_commands.clone().get_matches_from(vec!["test", "slot"]);
assert_eq!( assert_eq!(
parse_command(&test_get_slot, &default_keypair_file, None).unwrap(), parse_command(&test_get_slot, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetSlot { command: CliCommand::GetSlot {
commitment_config: CommitmentConfig::recent(), commitment_config: CommitmentConfig::recent(),
@@ -1265,7 +1265,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "epoch"]); .get_matches_from(vec!["test", "epoch"]);
assert_eq!( assert_eq!(
parse_command(&test_get_epoch, &default_keypair_file, None).unwrap(), parse_command(&test_get_epoch, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetEpoch { command: CliCommand::GetEpoch {
commitment_config: CommitmentConfig::recent(), commitment_config: CommitmentConfig::recent(),
@@ -1278,7 +1278,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "total-supply"]); .get_matches_from(vec!["test", "total-supply"]);
assert_eq!( assert_eq!(
parse_command(&test_total_supply, &default_keypair_file, None).unwrap(), parse_command(&test_total_supply, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::TotalSupply { command: CliCommand::TotalSupply {
commitment_config: CommitmentConfig::recent(), commitment_config: CommitmentConfig::recent(),
@@ -1291,7 +1291,7 @@ mod tests {
.clone() .clone()
.get_matches_from(vec!["test", "transaction-count"]); .get_matches_from(vec!["test", "transaction-count"]);
assert_eq!( assert_eq!(
parse_command(&test_transaction_count, &default_keypair_file, None).unwrap(), parse_command(&test_transaction_count, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetTransactionCount { command: CliCommand::GetTransactionCount {
commitment_config: CommitmentConfig::recent(), commitment_config: CommitmentConfig::recent(),
@@ -1312,7 +1312,7 @@ mod tests {
"--confirmed", "--confirmed",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_ping, &default_keypair_file, None).unwrap(), parse_command(&test_ping, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::Ping { command: CliCommand::Ping {
lamports: 1, lamports: 1,

44
cli/src/main.rs
View File

@@ -2,9 +2,7 @@ use clap::{crate_description, crate_name, AppSettings, Arg, ArgGroup, ArgMatches
use console::style; use console::style;
use solana_clap_utils::{ use solana_clap_utils::{
input_validators::is_url, input_validators::is_url, keypair::SKIP_SEED_PHRASE_VALIDATION_ARG, offline::SIGN_ONLY_ARG,
keypair::{check_for_usb, SKIP_SEED_PHRASE_VALIDATION_ARG},
offline::SIGN_ONLY_ARG,
DisplayError, DisplayError,
}; };
use solana_cli::{ use solana_cli::{
@@ -13,10 +11,10 @@ use solana_cli::{
display::{println_name_value, println_name_value_or}, display::{println_name_value, println_name_value_or},
}; };
use solana_cli_config::{Config, CONFIG_FILE}; use solana_cli_config::{Config, CONFIG_FILE};
use solana_remote_wallet::remote_wallet::{maybe_wallet_manager, RemoteWalletManager}; use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use std::{error, sync::Arc}; use std::{error, sync::Arc};
fn parse_settings(matches: &ArgMatches<'_>) -> Result<Option<bool>, Box<dyn error::Error>> { fn parse_settings(matches: &ArgMatches<'_>) -> Result<bool, Box<dyn error::Error>> {
let parse_args = match matches.subcommand() { let parse_args = match matches.subcommand() {
("config", Some(matches)) => match matches.subcommand() { ("config", Some(matches)) => match matches.subcommand() {
("get", Some(subcommand_matches)) => { ("get", Some(subcommand_matches)) => {
@@ -54,7 +52,7 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<Option<bool>, Box<dyn erro
style("No config file found.").bold() style("No config file found.").bold()
); );
} }
None false
} }
("set", Some(subcommand_matches)) => { ("set", Some(subcommand_matches)) => {
if let Some(config_file) = matches.value_of("config_file") { if let Some(config_file) = matches.value_of("config_file") {
@@ -94,26 +92,18 @@ fn parse_settings(matches: &ArgMatches<'_>) -> Result<Option<bool>, Box<dyn erro
style("No config file found.").bold() style("No config file found.").bold()
); );
} }
None false
} }
_ => unreachable!(), _ => unreachable!(),
}, },
_ => { _ => true,
let need_wallet_manager = if let Some(config_file) = matches.value_of("config_file") {
let config = Config::load(config_file).unwrap_or_default();
check_for_usb([config.keypair_path].iter())
} else {
false
};
Some(need_wallet_manager)
}
}; };
Ok(parse_args) Ok(parse_args)
} }
pub fn parse_args<'a>( pub fn parse_args<'a>(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<Arc<RemoteWalletManager>>, mut wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<(CliConfig<'a>, CliSigners), Box<dyn error::Error>> { ) -> Result<(CliConfig<'a>, CliSigners), Box<dyn error::Error>> {
let config = if let Some(config_file) = matches.value_of("config_file") { let config = if let Some(config_file) = matches.value_of("config_file") {
Config::load(config_file).unwrap_or_default() Config::load(config_file).unwrap_or_default()
@@ -136,7 +126,7 @@ pub fn parse_args<'a>(
); );
let CliCommandInfo { command, signers } = let CliCommandInfo { command, signers } =
parse_command(&matches, &default_signer_path, wallet_manager.as_ref())?; parse_command(&matches, &default_signer_path, &mut wallet_manager)?;
let output_format = matches let output_format = matches
.value_of("output_format") .value_of("output_format")
@@ -262,22 +252,14 @@ fn main() -> Result<(), Box<dyn error::Error>> {
) )
.get_matches(); .get_matches();
do_main(&matches, check_for_usb(std::env::args())) do_main(&matches).map_err(|err| DisplayError::new_as_boxed(err).into())
.map_err(|err| DisplayError::new_as_boxed(err).into())
} }
fn do_main( fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
matches: &ArgMatches<'_>, if parse_settings(&matches)? {
need_wallet_manager: bool, let mut wallet_manager = None;
) -> Result<(), Box<dyn error::Error>> {
if let Some(config_need_wallet_manager) = parse_settings(&matches)? {
let wallet_manager = if need_wallet_manager || config_need_wallet_manager {
maybe_wallet_manager()?
} else {
None
};
let (mut config, signers) = parse_args(&matches, wallet_manager)?; let (mut config, signers) = parse_args(&matches, &mut wallet_manager)?;
config.signers = signers.iter().map(|s| s.as_ref()).collect(); config.signers = signers.iter().map(|s| s.as_ref()).collect();
let result = process_command(&config)?; let result = process_command(&config)?;
let (_, submatches) = matches.subcommand(); let (_, submatches) = matches.subcommand();

42
cli/src/nonce.rs
View File

@@ -279,7 +279,7 @@ pub fn data_from_state(state: &State) -> Result<&Data, CliNonceError> {
pub fn parse_authorize_nonce_account( pub fn parse_authorize_nonce_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap(); let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
let new_authority = pubkey_of_signer(matches, "new_authority", wallet_manager)?.unwrap(); let new_authority = pubkey_of_signer(matches, "new_authority", wallet_manager)?.unwrap();
@@ -307,7 +307,7 @@ pub fn parse_authorize_nonce_account(
pub fn parse_nonce_create_account( pub fn parse_nonce_create_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let (nonce_account, nonce_account_pubkey) = let (nonce_account, nonce_account_pubkey) =
signer_of(matches, "nonce_account_keypair", wallet_manager)?; signer_of(matches, "nonce_account_keypair", wallet_manager)?;
@@ -336,7 +336,7 @@ pub fn parse_nonce_create_account(
pub fn parse_get_nonce( pub fn parse_get_nonce(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let nonce_account_pubkey = let nonce_account_pubkey =
pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -350,7 +350,7 @@ pub fn parse_get_nonce(
pub fn parse_new_nonce( pub fn parse_new_nonce(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap(); let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
let (nonce_authority, nonce_authority_pubkey) = let (nonce_authority, nonce_authority_pubkey) =
@@ -375,7 +375,7 @@ pub fn parse_new_nonce(
pub fn parse_show_nonce_account( pub fn parse_show_nonce_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let nonce_account_pubkey = let nonce_account_pubkey =
pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
@@ -393,7 +393,7 @@ pub fn parse_show_nonce_account(
pub fn parse_withdraw_from_nonce_account( pub fn parse_withdraw_from_nonce_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap(); let nonce_account = pubkey_of_signer(matches, "nonce_account_pubkey", wallet_manager)?.unwrap();
let destination_account_pubkey = let destination_account_pubkey =
@@ -688,7 +688,12 @@ mod tests {
&Pubkey::default().to_string(), &Pubkey::default().to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(), parse_command(
&test_authorize_nonce_account,
&default_keypair_file,
&mut None
)
.unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::AuthorizeNonceAccount { command: CliCommand::AuthorizeNonceAccount {
nonce_account: nonce_account_pubkey, nonce_account: nonce_account_pubkey,
@@ -709,7 +714,12 @@ mod tests {
&authority_keypair_file, &authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(), parse_command(
&test_authorize_nonce_account,
&default_keypair_file,
&mut None
)
.unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::AuthorizeNonceAccount { command: CliCommand::AuthorizeNonceAccount {
nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(), nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
@@ -731,7 +741,7 @@ mod tests {
"50", "50",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(), parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateNonceAccount { command: CliCommand::CreateNonceAccount {
nonce_account: 1, nonce_account: 1,
@@ -756,7 +766,7 @@ mod tests {
&authority_keypair_file, &authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(), parse_command(&test_create_nonce_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateNonceAccount { command: CliCommand::CreateNonceAccount {
nonce_account: 1, nonce_account: 1,
@@ -778,7 +788,7 @@ mod tests {
&nonce_account_string, &nonce_account_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_get_nonce, &default_keypair_file, None).unwrap(), parse_command(&test_get_nonce, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::GetNonce(nonce_account_keypair.pubkey()), command: CliCommand::GetNonce(nonce_account_keypair.pubkey()),
signers: vec![], signers: vec![],
@@ -792,7 +802,7 @@ mod tests {
.get_matches_from(vec!["test", "new-nonce", &keypair_file]); .get_matches_from(vec!["test", "new-nonce", &keypair_file]);
let nonce_account = read_keypair_file(&keypair_file).unwrap(); let nonce_account = read_keypair_file(&keypair_file).unwrap();
assert_eq!( assert_eq!(
parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(), parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::NewNonce { command: CliCommand::NewNonce {
nonce_account: nonce_account.pubkey(), nonce_account: nonce_account.pubkey(),
@@ -812,7 +822,7 @@ mod tests {
]); ]);
let nonce_account = read_keypair_file(&keypair_file).unwrap(); let nonce_account = read_keypair_file(&keypair_file).unwrap();
assert_eq!( assert_eq!(
parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(), parse_command(&test_new_nonce, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::NewNonce { command: CliCommand::NewNonce {
nonce_account: nonce_account.pubkey(), nonce_account: nonce_account.pubkey(),
@@ -832,7 +842,7 @@ mod tests {
&nonce_account_string, &nonce_account_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_show_nonce_account, &default_keypair_file, None).unwrap(), parse_command(&test_show_nonce_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::ShowNonceAccount { command: CliCommand::ShowNonceAccount {
nonce_account_pubkey: nonce_account_keypair.pubkey(), nonce_account_pubkey: nonce_account_keypair.pubkey(),
@@ -854,7 +864,7 @@ mod tests {
parse_command( parse_command(
&test_withdraw_from_nonce_account, &test_withdraw_from_nonce_account,
&default_keypair_file, &default_keypair_file,
None &mut None
) )
.unwrap(), .unwrap(),
CliCommandInfo { CliCommandInfo {
@@ -882,7 +892,7 @@ mod tests {
parse_command( parse_command(
&test_withdraw_from_nonce_account, &test_withdraw_from_nonce_account,
&default_keypair_file, &default_keypair_file,
None &mut None
) )
.unwrap(), .unwrap(),
CliCommandInfo { CliCommandInfo {

102
cli/src/stake.rs
View File

@@ -402,7 +402,7 @@ impl StakeSubCommands for App<'_, '_> {
pub fn parse_stake_create_account( pub fn parse_stake_create_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let seed = matches.value_of("seed").map(|s| s.to_string()); let seed = matches.value_of("seed").map(|s| s.to_string());
let epoch = value_of(matches, "lockup_epoch").unwrap_or(0); let epoch = value_of(matches, "lockup_epoch").unwrap_or(0);
@@ -454,7 +454,7 @@ pub fn parse_stake_create_account(
pub fn parse_stake_delegate_stake( pub fn parse_stake_delegate_stake(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -496,7 +496,7 @@ pub fn parse_stake_delegate_stake(
pub fn parse_stake_authorize( pub fn parse_stake_authorize(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -579,7 +579,7 @@ pub fn parse_stake_authorize(
pub fn parse_split_stake( pub fn parse_split_stake(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -624,7 +624,7 @@ pub fn parse_split_stake(
pub fn parse_stake_deactivate_stake( pub fn parse_stake_deactivate_stake(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -661,7 +661,7 @@ pub fn parse_stake_deactivate_stake(
pub fn parse_stake_withdraw_stake( pub fn parse_stake_withdraw_stake(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -703,7 +703,7 @@ pub fn parse_stake_withdraw_stake(
pub fn parse_stake_set_lockup( pub fn parse_stake_set_lockup(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -748,7 +748,7 @@ pub fn parse_stake_set_lockup(
pub fn parse_show_stake_account( pub fn parse_show_stake_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let stake_account_pubkey = let stake_account_pubkey =
pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "stake_account_pubkey", wallet_manager)?.unwrap();
@@ -1513,7 +1513,7 @@ mod tests {
&new_withdraw_string, &new_withdraw_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1547,7 +1547,7 @@ mod tests {
&withdraw_authority_keypair_file, &withdraw_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1585,7 +1585,7 @@ mod tests {
&withdraw_authority_keypair_file, &withdraw_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1615,7 +1615,7 @@ mod tests {
&new_stake_string, &new_stake_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1639,7 +1639,7 @@ mod tests {
&stake_authority_keypair_file, &stake_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1669,7 +1669,7 @@ mod tests {
&withdraw_authority_keypair_file, &withdraw_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1696,7 +1696,7 @@ mod tests {
&new_withdraw_string, &new_withdraw_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1724,7 +1724,7 @@ mod tests {
&withdraw_authority_keypair_file, &withdraw_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_stake_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_stake_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1762,7 +1762,7 @@ mod tests {
"--sign-only", "--sign-only",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1795,7 +1795,7 @@ mod tests {
&pubkey.to_string(), &pubkey.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1841,7 +1841,7 @@ mod tests {
&pubkey2.to_string(), &pubkey2.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1873,7 +1873,7 @@ mod tests {
&blockhash_string, &blockhash_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1910,7 +1910,7 @@ mod tests {
&nonce_keypair_file, &nonce_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1946,7 +1946,7 @@ mod tests {
&fee_payer_keypair_file, &fee_payer_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -1980,7 +1980,7 @@ mod tests {
&signer, &signer,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize, &default_keypair_file, None).unwrap(), parse_command(&test_authorize, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::StakeAuthorize { command: CliCommand::StakeAuthorize {
stake_account_pubkey, stake_account_pubkey,
@@ -2021,7 +2021,7 @@ mod tests {
"43", "43",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_stake_account, &default_keypair_file, None).unwrap(), parse_command(&test_create_stake_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateStakeAccount { command: CliCommand::CreateStakeAccount {
stake_account: 1, stake_account: 1,
@@ -2062,7 +2062,12 @@ mod tests {
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_stake_account2, &default_keypair_file, None).unwrap(), parse_command(
&test_create_stake_account2,
&default_keypair_file,
&mut None
)
.unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateStakeAccount { command: CliCommand::CreateStakeAccount {
stake_account: 1, stake_account: 1,
@@ -2115,7 +2120,12 @@ mod tests {
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_stake_account2, &default_keypair_file, None).unwrap(), parse_command(
&test_create_stake_account2,
&default_keypair_file,
&mut None
)
.unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateStakeAccount { command: CliCommand::CreateStakeAccount {
stake_account: 1, stake_account: 1,
@@ -2151,7 +2161,7 @@ mod tests {
&vote_account_string, &vote_account_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2180,7 +2190,7 @@ mod tests {
&stake_authority_keypair_file, &stake_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2211,7 +2221,7 @@ mod tests {
&vote_account_string, &vote_account_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2240,7 +2250,7 @@ mod tests {
&blockhash_string, &blockhash_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2270,7 +2280,7 @@ mod tests {
"--sign-only", "--sign-only",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2304,7 +2314,7 @@ mod tests {
&key1.to_string(), &key1.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2350,7 +2360,7 @@ mod tests {
&key2.to_string(), &key2.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2387,7 +2397,7 @@ mod tests {
&fee_payer_keypair_file, &fee_payer_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_delegate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_delegate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DelegateStake { command: CliCommand::DelegateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2417,7 +2427,7 @@ mod tests {
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_withdraw_stake, &default_keypair_file, None).unwrap(), parse_command(&test_withdraw_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::WithdrawStake { command: CliCommand::WithdrawStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2446,7 +2456,7 @@ mod tests {
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_withdraw_stake, &default_keypair_file, None).unwrap(), parse_command(&test_withdraw_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::WithdrawStake { command: CliCommand::WithdrawStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2490,7 +2500,7 @@ mod tests {
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_withdraw_stake, &default_keypair_file, None).unwrap(), parse_command(&test_withdraw_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::WithdrawStake { command: CliCommand::WithdrawStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2522,7 +2532,7 @@ mod tests {
&stake_account_string, &stake_account_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2546,7 +2556,7 @@ mod tests {
&stake_authority_keypair_file, &stake_authority_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2577,7 +2587,7 @@ mod tests {
&blockhash_string, &blockhash_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2604,7 +2614,7 @@ mod tests {
"--sign-only", "--sign-only",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2635,7 +2645,7 @@ mod tests {
&key1.to_string(), &key1.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2678,7 +2688,7 @@ mod tests {
&key2.to_string(), &key2.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2709,7 +2719,7 @@ mod tests {
&fee_payer_keypair_file, &fee_payer_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_deactivate_stake, &default_keypair_file, None).unwrap(), parse_command(&test_deactivate_stake, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::DeactivateStake { command: CliCommand::DeactivateStake {
stake_account_pubkey, stake_account_pubkey,
@@ -2743,7 +2753,7 @@ mod tests {
"50", "50",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_split_stake_account, &default_keypair_file, None).unwrap(), parse_command(&test_split_stake_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::SplitStake { command: CliCommand::SplitStake {
stake_account_pubkey: stake_account_keypair.pubkey(), stake_account_pubkey: stake_account_keypair.pubkey(),
@@ -2804,7 +2814,7 @@ mod tests {
&stake_signer, &stake_signer,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_split_stake_account, &default_keypair_file, None).unwrap(), parse_command(&test_split_stake_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::SplitStake { command: CliCommand::SplitStake {
stake_account_pubkey: stake_account_keypair.pubkey(), stake_account_pubkey: stake_account_keypair.pubkey(),

14
cli/src/storage.rs
View File

@@ -102,7 +102,7 @@ impl StorageSubCommands for App<'_, '_> {
pub fn parse_storage_create_archiver_account( pub fn parse_storage_create_archiver_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let account_owner = let account_owner =
pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap();
@@ -130,7 +130,7 @@ pub fn parse_storage_create_archiver_account(
pub fn parse_storage_create_validator_account( pub fn parse_storage_create_validator_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let account_owner = let account_owner =
pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "storage_account_owner", wallet_manager)?.unwrap();
@@ -158,7 +158,7 @@ pub fn parse_storage_create_validator_account(
pub fn parse_storage_claim_reward( pub fn parse_storage_claim_reward(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let node_account_pubkey = let node_account_pubkey =
pubkey_of_signer(matches, "node_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "node_account_pubkey", wallet_manager)?.unwrap();
@@ -180,7 +180,7 @@ pub fn parse_storage_claim_reward(
pub fn parse_storage_get_account_command( pub fn parse_storage_get_account_command(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let storage_account_pubkey = let storage_account_pubkey =
pubkey_of_signer(matches, "storage_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "storage_account_pubkey", wallet_manager)?.unwrap();
@@ -330,7 +330,7 @@ mod tests {
parse_command( parse_command(
&test_create_archiver_storage_account, &test_create_archiver_storage_account,
&default_keypair_file, &default_keypair_file,
None &mut None
) )
.unwrap(), .unwrap(),
CliCommandInfo { CliCommandInfo {
@@ -362,7 +362,7 @@ mod tests {
parse_command( parse_command(
&test_create_validator_storage_account, &test_create_validator_storage_account,
&default_keypair_file, &default_keypair_file,
None &mut None
) )
.unwrap(), .unwrap(),
CliCommandInfo { CliCommandInfo {
@@ -385,7 +385,7 @@ mod tests {
&storage_account_string, &storage_account_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_claim_storage_reward, &default_keypair_file, None).unwrap(), parse_command(&test_claim_storage_reward, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::ClaimStorageReward { command: CliCommand::ClaimStorageReward {
node_account_pubkey: pubkey, node_account_pubkey: pubkey,

2
cli/src/validator_info.rs
View File

@@ -228,7 +228,7 @@ impl ValidatorInfoSubCommands for App<'_, '_> {
pub fn parse_validator_info_command( pub fn parse_validator_info_command(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let info_pubkey = pubkey_of(matches, "info_pubkey"); let info_pubkey = pubkey_of(matches, "info_pubkey");
// Prepare validator info // Prepare validator info

28
cli/src/vote.rs
View File

@@ -243,7 +243,7 @@ impl VoteSubCommands for App<'_, '_> {
pub fn parse_create_vote_account( pub fn parse_create_vote_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let (vote_account, _) = signer_of(matches, "vote_account", wallet_manager)?; let (vote_account, _) = signer_of(matches, "vote_account", wallet_manager)?;
let seed = matches.value_of("seed").map(|s| s.to_string()); let seed = matches.value_of("seed").map(|s| s.to_string());
@@ -276,7 +276,7 @@ pub fn parse_create_vote_account(
pub fn parse_vote_authorize( pub fn parse_vote_authorize(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
vote_authorize: VoteAuthorize, vote_authorize: VoteAuthorize,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let vote_account_pubkey = let vote_account_pubkey =
@@ -306,7 +306,7 @@ pub fn parse_vote_authorize(
pub fn parse_vote_update_validator( pub fn parse_vote_update_validator(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let vote_account_pubkey = let vote_account_pubkey =
pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
@@ -333,7 +333,7 @@ pub fn parse_vote_update_validator(
pub fn parse_vote_get_account_command( pub fn parse_vote_get_account_command(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let vote_account_pubkey = let vote_account_pubkey =
pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
@@ -356,7 +356,7 @@ pub fn parse_vote_get_account_command(
pub fn parse_withdraw_from_vote_account( pub fn parse_withdraw_from_vote_account(
matches: &ArgMatches<'_>, matches: &ArgMatches<'_>,
default_signer_path: &str, default_signer_path: &str,
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<CliCommandInfo, CliError> { ) -> Result<CliCommandInfo, CliError> {
let vote_account_pubkey = let vote_account_pubkey =
pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap(); pubkey_of_signer(matches, "vote_account_pubkey", wallet_manager)?.unwrap();
@@ -683,7 +683,7 @@ mod tests {
&pubkey2_string, &pubkey2_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize_voter, &default_keypair_file, None).unwrap(), parse_command(&test_authorize_voter, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::VoteAuthorize { command: CliCommand::VoteAuthorize {
vote_account_pubkey: pubkey, vote_account_pubkey: pubkey,
@@ -706,7 +706,7 @@ mod tests {
&pubkey2_string, &pubkey2_string,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_authorize_voter, &default_keypair_file, None).unwrap(), parse_command(&test_authorize_voter, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::VoteAuthorize { command: CliCommand::VoteAuthorize {
vote_account_pubkey: pubkey, vote_account_pubkey: pubkey,
@@ -736,7 +736,7 @@ mod tests {
"10", "10",
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_vote_account, &default_keypair_file, None).unwrap(), parse_command(&test_create_vote_account, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateVoteAccount { command: CliCommand::CreateVoteAccount {
seed: None, seed: None,
@@ -764,7 +764,7 @@ mod tests {
&identity_keypair_file, &identity_keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_vote_account2, &default_keypair_file, None).unwrap(), parse_command(&test_create_vote_account2, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateVoteAccount { command: CliCommand::CreateVoteAccount {
seed: None, seed: None,
@@ -796,7 +796,7 @@ mod tests {
&authed.to_string(), &authed.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_vote_account3, &default_keypair_file, None).unwrap(), parse_command(&test_create_vote_account3, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateVoteAccount { command: CliCommand::CreateVoteAccount {
seed: None, seed: None,
@@ -826,7 +826,7 @@ mod tests {
&authed.to_string(), &authed.to_string(),
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_create_vote_account4, &default_keypair_file, None).unwrap(), parse_command(&test_create_vote_account4, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::CreateVoteAccount { command: CliCommand::CreateVoteAccount {
seed: None, seed: None,
@@ -851,7 +851,7 @@ mod tests {
&keypair_file, &keypair_file,
]); ]);
assert_eq!( assert_eq!(
parse_command(&test_update_validator, &default_keypair_file, None).unwrap(), parse_command(&test_update_validator, &default_keypair_file, &mut None).unwrap(),
CliCommandInfo { CliCommandInfo {
command: CliCommand::VoteUpdateValidator { command: CliCommand::VoteUpdateValidator {
vote_account_pubkey: pubkey, vote_account_pubkey: pubkey,
@@ -877,7 +877,7 @@ mod tests {
parse_command( parse_command(
&test_withdraw_from_vote_account, &test_withdraw_from_vote_account,
&default_keypair_file, &default_keypair_file,
None &mut None
) )
.unwrap(), .unwrap(),
CliCommandInfo { CliCommandInfo {
@@ -908,7 +908,7 @@ mod tests {
parse_command( parse_command(
&test_withdraw_from_vote_account, &test_withdraw_from_vote_account,
&default_keypair_file, &default_keypair_file,
None &mut None
) )
.unwrap(), .unwrap(),
CliCommandInfo { CliCommandInfo {

20
keygen/src/keygen.rs
View File

@@ -8,13 +8,13 @@ use num_cpus;
use solana_clap_utils::{ use solana_clap_utils::{
input_validators::is_derivation, input_validators::is_derivation,
keypair::{ keypair::{
check_for_usb, keypair_from_seed_phrase, prompt_passphrase, signer_from_path, keypair_from_seed_phrase, prompt_passphrase, signer_from_path,
SKIP_SEED_PHRASE_VALIDATION_ARG, SKIP_SEED_PHRASE_VALIDATION_ARG,
}, },
DisplayError, DisplayError,
}; };
use solana_cli_config::{Config, CONFIG_FILE}; use solana_cli_config::{Config, CONFIG_FILE};
use solana_remote_wallet::remote_wallet::{maybe_wallet_manager, RemoteWalletManager}; use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{ use solana_sdk::{
instruction::{AccountMeta, Instruction}, instruction::{AccountMeta, Instruction},
message::Message, message::Message,
@@ -53,7 +53,7 @@ fn check_for_overwrite(outfile: &str, matches: &ArgMatches) {
fn get_keypair_from_matches( fn get_keypair_from_matches(
matches: &ArgMatches, matches: &ArgMatches,
config: Config, config: Config,
wallet_manager: Option<Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
) -> Result<Box<dyn Signer>, Box<dyn error::Error>> { ) -> Result<Box<dyn Signer>, Box<dyn error::Error>> {
let mut path = dirs::home_dir().expect("home directory"); let mut path = dirs::home_dir().expect("home directory");
let path = if matches.is_present("keypair") { let path = if matches.is_present("keypair") {
@@ -64,7 +64,7 @@ fn get_keypair_from_matches(
path.extend(&[".config", "solana", "id.json"]); path.extend(&[".config", "solana", "id.json"]);
path.to_str().unwrap() path.to_str().unwrap()
}; };
signer_from_path(matches, path, "pubkey recovery", wallet_manager.as_ref()) signer_from_path(matches, path, "pubkey recovery", wallet_manager)
} }
fn output_keypair( fn output_keypair(
@@ -407,16 +407,12 @@ fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
Config::default() Config::default()
}; };
let wallet_manager = let mut wallet_manager = None;
if check_for_usb(std::env::args()) || check_for_usb([config.keypair_path.clone()].iter()) {
maybe_wallet_manager()?
} else {
None
};
match matches.subcommand() { match matches.subcommand() {
("pubkey", Some(matches)) => { ("pubkey", Some(matches)) => {
let pubkey = get_keypair_from_matches(matches, config, wallet_manager)?.try_pubkey()?; let pubkey =
get_keypair_from_matches(matches, config, &mut wallet_manager)?.try_pubkey()?;
if matches.is_present("outfile") { if matches.is_present("outfile") {
let outfile = matches.value_of("outfile").unwrap(); let outfile = matches.value_of("outfile").unwrap();
@@ -605,7 +601,7 @@ fn do_main(matches: &ArgMatches<'_>) -> Result<(), Box<dyn error::Error>> {
} }
} }
("verify", Some(matches)) => { ("verify", Some(matches)) => {
let keypair = get_keypair_from_matches(matches, config, wallet_manager)?; let keypair = get_keypair_from_matches(matches, config, &mut wallet_manager)?;
let simple_message = Message::new(&[Instruction::new( let simple_message = Message::new(&[Instruction::new(
Pubkey::default(), Pubkey::default(),
&0, &0,

47
stake-accounts/src/args.rs
View File

@@ -1,6 +1,6 @@
use clap::ArgMatches; use clap::ArgMatches;
use solana_clap_utils::keypair::{pubkey_from_path, signer_from_path}; use solana_clap_utils::keypair::{pubkey_from_path, signer_from_path};
use solana_remote_wallet::remote_wallet::{maybe_wallet_manager, RemoteWalletManager}; use solana_remote_wallet::remote_wallet::RemoteWalletManager;
use solana_sdk::{pubkey::Pubkey, signature::Signer}; use solana_sdk::{pubkey::Pubkey, signature::Signer};
use std::error::Error; use std::error::Error;
use std::sync::Arc; use std::sync::Arc;
@@ -64,7 +64,7 @@ pub(crate) struct Args<P, K> {
} }
fn resolve_stake_authority( fn resolve_stake_authority(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Box<dyn Signer>, Box<dyn Error>> { ) -> Result<Box<dyn Signer>, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -72,7 +72,7 @@ fn resolve_stake_authority(
} }
fn resolve_withdraw_authority( fn resolve_withdraw_authority(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Box<dyn Signer>, Box<dyn Error>> { ) -> Result<Box<dyn Signer>, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -80,7 +80,7 @@ fn resolve_withdraw_authority(
} }
fn resolve_new_stake_authority( fn resolve_new_stake_authority(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Pubkey, Box<dyn Error>> { ) -> Result<Pubkey, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -88,7 +88,7 @@ fn resolve_new_stake_authority(
} }
fn resolve_new_withdraw_authority( fn resolve_new_withdraw_authority(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Pubkey, Box<dyn Error>> { ) -> Result<Pubkey, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -96,7 +96,7 @@ fn resolve_new_withdraw_authority(
} }
fn resolve_fee_payer( fn resolve_fee_payer(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Box<dyn Signer>, Box<dyn Error>> { ) -> Result<Box<dyn Signer>, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -104,7 +104,7 @@ fn resolve_fee_payer(
} }
fn resolve_base_pubkey( fn resolve_base_pubkey(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Pubkey, Box<dyn Error>> { ) -> Result<Pubkey, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -112,7 +112,7 @@ fn resolve_base_pubkey(
} }
fn resolve_new_base_keypair( fn resolve_new_base_keypair(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
key_url: &str, key_url: &str,
) -> Result<Box<dyn Signer>, Box<dyn Error>> { ) -> Result<Box<dyn Signer>, Box<dyn Error>> {
let matches = ArgMatches::default(); let matches = ArgMatches::default();
@@ -120,7 +120,7 @@ fn resolve_new_base_keypair(
} }
fn resolve_authorize_args( fn resolve_authorize_args(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
args: &AuthorizeArgs<String, String>, args: &AuthorizeArgs<String, String>,
) -> Result<AuthorizeArgs<Pubkey, Box<dyn Signer>>, Box<dyn Error>> { ) -> Result<AuthorizeArgs<Pubkey, Box<dyn Signer>>, Box<dyn Error>> {
let resolved_args = AuthorizeArgs { let resolved_args = AuthorizeArgs {
@@ -142,7 +142,7 @@ fn resolve_authorize_args(
} }
fn resolve_rebase_args( fn resolve_rebase_args(
wallet_manager: Option<&Arc<RemoteWalletManager>>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>,
args: &RebaseArgs<String, String>, args: &RebaseArgs<String, String>,
) -> Result<RebaseArgs<Pubkey, Box<dyn Signer>>, Box<dyn Error>> { ) -> Result<RebaseArgs<Pubkey, Box<dyn Signer>>, Box<dyn Error>> {
let resolved_args = RebaseArgs { let resolved_args = RebaseArgs {
@@ -158,36 +158,35 @@ fn resolve_rebase_args(
pub(crate) fn resolve_command( pub(crate) fn resolve_command(
command: &Command<String, String>, command: &Command<String, String>,
) -> Result<Command<Pubkey, Box<dyn Signer>>, Box<dyn Error>> { ) -> Result<Command<Pubkey, Box<dyn Signer>>, Box<dyn Error>> {
let wallet_manager = maybe_wallet_manager()?; let mut wallet_manager = None;
let wallet_manager = wallet_manager.as_ref();
let matches = ArgMatches::default(); let matches = ArgMatches::default();
match command { match command {
Command::New(args) => { Command::New(args) => {
let resolved_args = NewArgs { let resolved_args = NewArgs {
fee_payer: resolve_fee_payer(wallet_manager, &args.fee_payer)?, fee_payer: resolve_fee_payer(&mut wallet_manager, &args.fee_payer)?,
funding_keypair: signer_from_path( funding_keypair: signer_from_path(
&matches, &matches,
&args.funding_keypair, &args.funding_keypair,
"funding keypair", "funding keypair",
wallet_manager, &mut wallet_manager,
)?, )?,
base_keypair: signer_from_path( base_keypair: signer_from_path(
&matches, &matches,
&args.base_keypair, &args.base_keypair,
"base keypair", "base keypair",
wallet_manager, &mut wallet_manager,
)?, )?,
stake_authority: pubkey_from_path( stake_authority: pubkey_from_path(
&matches, &matches,
&args.stake_authority, &args.stake_authority,
"stake authority", "stake authority",
wallet_manager, &mut wallet_manager,
)?, )?,
withdraw_authority: pubkey_from_path( withdraw_authority: pubkey_from_path(
&matches, &matches,
&args.withdraw_authority, &args.withdraw_authority,
"withdraw authority", "withdraw authority",
wallet_manager, &mut wallet_manager,
)?, )?,
lamports: args.lamports, lamports: args.lamports,
index: args.index, index: args.index,
@@ -196,36 +195,36 @@ pub(crate) fn resolve_command(
} }
Command::Count(args) => { Command::Count(args) => {
let resolved_args = CountArgs { let resolved_args = CountArgs {
base_pubkey: resolve_base_pubkey(wallet_manager, &args.base_pubkey)?, base_pubkey: resolve_base_pubkey(&mut wallet_manager, &args.base_pubkey)?,
}; };
Ok(Command::Count(resolved_args)) Ok(Command::Count(resolved_args))
} }
Command::Addresses(args) => { Command::Addresses(args) => {
let resolved_args = QueryArgs { let resolved_args = QueryArgs {
base_pubkey: resolve_base_pubkey(wallet_manager, &args.base_pubkey)?, base_pubkey: resolve_base_pubkey(&mut wallet_manager, &args.base_pubkey)?,
num_accounts: args.num_accounts, num_accounts: args.num_accounts,
}; };
Ok(Command::Addresses(resolved_args)) Ok(Command::Addresses(resolved_args))
} }
Command::Balance(args) => { Command::Balance(args) => {
let resolved_args = QueryArgs { let resolved_args = QueryArgs {
base_pubkey: resolve_base_pubkey(wallet_manager, &args.base_pubkey)?, base_pubkey: resolve_base_pubkey(&mut wallet_manager, &args.base_pubkey)?,
num_accounts: args.num_accounts, num_accounts: args.num_accounts,
}; };
Ok(Command::Balance(resolved_args)) Ok(Command::Balance(resolved_args))
} }
Command::Authorize(args) => { Command::Authorize(args) => {
let resolved_args = resolve_authorize_args(wallet_manager, &args)?; let resolved_args = resolve_authorize_args(&mut wallet_manager, &args)?;
Ok(Command::Authorize(resolved_args)) Ok(Command::Authorize(resolved_args))
} }
Command::Rebase(args) => { Command::Rebase(args) => {
let resolved_args = resolve_rebase_args(wallet_manager, &args)?; let resolved_args = resolve_rebase_args(&mut wallet_manager, &args)?;
Ok(Command::Rebase(resolved_args)) Ok(Command::Rebase(resolved_args))
} }
Command::Move(args) => { Command::Move(args) => {
let resolved_args = MoveArgs { let resolved_args = MoveArgs {
authorize_args: resolve_authorize_args(wallet_manager, &args.authorize_args)?, authorize_args: resolve_authorize_args(&mut wallet_manager, &args.authorize_args)?,
rebase_args: resolve_rebase_args(wallet_manager, &args.rebase_args)?, rebase_args: resolve_rebase_args(&mut wallet_manager, &args.rebase_args)?,
}; };
Ok(Command::Move(Box::new(resolved_args))) Ok(Command::Move(Box::new(resolved_args)))
} }