Add offline signing support to CLI (#7104)

clap-utils/src/input_parsers.rs

@@ -3,8 +3,9 @@ use clap::ArgMatches;
 use solana_sdk::{
     native_token::sol_to_lamports,
     pubkey::Pubkey,
-    signature::{read_keypair_file, Keypair, KeypairUtil},
+    signature::{read_keypair_file, Keypair, KeypairUtil, Signature},
 };
+use std::str::FromStr;
 
 // Return parsed values from matches at `name`
 pub fn values_of<T>(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<T>>
@@ -50,6 +51,20 @@ pub fn pubkey_of(matches: &ArgMatches<'_>, name: &str) -> Option<Pubkey> {
     value_of(matches, name).or_else(|| keypair_of(matches, name).map(|keypair| keypair.pubkey()))
 }
 
+// Return pubkey/signature pairs for a string of the form pubkey=signature
+pub fn pubkeys_sigs_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<(Pubkey, Signature)>> {
+    matches.values_of(name).map(|values| {
+        values
+            .map(|pubkey_signer_string| {
+                let mut signer = pubkey_signer_string.split('=');
+                let key = Pubkey::from_str(signer.next().unwrap()).unwrap();
+                let sig = Signature::from_str(signer.next().unwrap()).unwrap();
+                (key, sig)
+            })
+            .collect()
+    })
+}
+
 pub fn amount_of(matches: &ArgMatches<'_>, name: &str, unit: &str) -> Option<u64> {
     if matches.value_of(unit) == Some("lamports") {
         value_of(matches, name)
@@ -172,4 +187,25 @@ mod tests {
 
         fs::remove_file(&outfile).unwrap();
     }
+
+    #[test]
+    fn test_pubkeys_sigs_of() {
+        let key1 = Pubkey::new_rand();
+        let key2 = Pubkey::new_rand();
+        let sig1 = Keypair::new().sign_message(&[0u8]);
+        let sig2 = Keypair::new().sign_message(&[1u8]);
+        let signer1 = format!("{}={}", key1, sig1);
+        let signer2 = format!("{}={}", key2, sig2);
+        let matches = app().clone().get_matches_from(vec![
+            "test",
+            "--multiple",
+            &signer1,
+            "--multiple",
+            &signer2,
+        ]);
+        assert_eq!(
+            pubkeys_sigs_of(&matches, "multiple"),
+            Some(vec![(key1, sig1), (key2, sig2)])
+        );
+    }
 }

clap-utils/src/input_validators.rs

@@ -1,6 +1,8 @@
 use crate::keypair::ASK_KEYWORD;
+use solana_sdk::hash::Hash;
 use solana_sdk::pubkey::Pubkey;
-use solana_sdk::signature::read_keypair_file;
+use solana_sdk::signature::{read_keypair_file, Signature};
+use std::str::FromStr;
 
 // Return an error if a pubkey cannot be parsed.
 pub fn is_pubkey(string: String) -> Result<(), String> {
@@ -10,6 +12,14 @@ pub fn is_pubkey(string: String) -> Result<(), String> {
     }
 }
 
+// Return an error if a hash cannot be parsed.
+pub fn is_hash(string: String) -> Result<(), String> {
+    match string.parse::<Hash>() {
+        Ok(_) => Ok(()),
+        Err(err) => Err(format!("{:?}", err)),
+    }
+}
+
 // Return an error if a keypair file cannot be parsed.
 pub fn is_keypair(string: String) -> Result<(), String> {
     read_keypair_file(&string)
@@ -32,6 +42,28 @@ pub fn is_pubkey_or_keypair(string: String) -> Result<(), String> {
     is_pubkey(string.clone()).or_else(|_| is_keypair(string))
 }
 
+// Return an error if string cannot be parsed as pubkey=signature string
+pub fn is_pubkey_sig(string: String) -> Result<(), String> {
+    let mut signer = string.split('=');
+    match Pubkey::from_str(
+        signer
+            .next()
+            .ok_or_else(|| "Malformed signer string".to_string())?,
+    ) {
+        Ok(_) => {
+            match Signature::from_str(
+                signer
+                    .next()
+                    .ok_or_else(|| "Malformed signer string".to_string())?,
+            ) {
+                Ok(_) => Ok(()),
+                Err(err) => Err(format!("{:?}", err)),
+            }
+        }
+        Err(err) => Err(format!("{:?}", err)),
+    }
+}
+
 // Return an error if a url cannot be parsed.
 pub fn is_url(string: String) -> Result<(), String> {
     match url::Url::parse(&string) {