CLI: Implement transfer command (#8108) (#8170)

automerge

cli/src/cli.rs

@@ -37,7 +37,7 @@ use solana_sdk::{
     native_token::lamports_to_sol,
     pubkey::Pubkey,
     signature::{keypair_from_seed, Keypair, KeypairUtil, Signature},
-    system_instruction::{create_address_with_seed, SystemError, MAX_ADDRESS_SEED_LEN},
+    system_instruction::{self, create_address_with_seed, SystemError, MAX_ADDRESS_SEED_LEN},
     system_transaction,
     transaction::{Transaction, TransactionError},
 };
@@ -398,7 +398,18 @@ pub enum CliCommand {
         use_lamports_unit: bool,
     },
     TimeElapsed(Pubkey, Pubkey, DateTime<Utc>), // TimeElapsed(to, process_id, timestamp)
-    Witness(Pubkey, Pubkey),                    // Witness(to, process_id)
+    Transfer {
+        lamports: u64,
+        to: Pubkey,
+        from: Option<SigningAuthority>,
+        sign_only: bool,
+        signers: Option<Vec<(Pubkey, Signature)>>,
+        blockhash_query: BlockhashQuery,
+        nonce_account: Option<Pubkey>,
+        nonce_authority: Option<SigningAuthority>,
+        fee_payer: Option<SigningAuthority>,
+    },
+    Witness(Pubkey, Pubkey), // Witness(to, process_id)
 }
 
 #[derive(Debug, PartialEq)]
@@ -726,6 +737,39 @@ pub fn parse_command(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, Box<dyn
                 require_keypair: true,
             })
         }
+        ("transfer", Some(matches)) => {
+            let lamports = required_lamports_from(matches, "amount", "unit")?;
+            let to = pubkey_of(&matches, "to").unwrap();
+            let sign_only = matches.is_present(SIGN_ONLY_ARG.name);
+            let signers = pubkeys_sigs_of(&matches, SIGNER_ARG.name);
+            let blockhash_query = BlockhashQuery::new_from_matches(matches);
+            let nonce_account = pubkey_of(&matches, NONCE_ARG.name);
+            let nonce_authority = SigningAuthority::new_from_matches(
+                &matches,
+                NONCE_AUTHORITY_ARG.name,
+                signers.as_deref(),
+            )?;
+            let fee_payer = SigningAuthority::new_from_matches(
+                &matches,
+                FEE_PAYER_ARG.name,
+                signers.as_deref(),
+            )?;
+            let from = SigningAuthority::new_from_matches(&matches, "from", signers.as_deref())?;
+            Ok(CliCommandInfo {
+                command: CliCommand::Transfer {
+                    lamports,
+                    to,
+                    from,
+                    sign_only,
+                    signers,
+                    blockhash_query,
+                    nonce_account,
+                    nonce_authority,
+                    fee_payer,
+                },
+                require_keypair: true,
+            })
+        }
         //
         ("", None) => {
             eprintln!("{}", matches.usage());
@@ -1254,6 +1298,75 @@ fn process_time_elapsed(
     log_instruction_custom_error::<BudgetError>(result)
 }
 
+#[allow(clippy::too_many_arguments)]
+fn process_transfer(
+    rpc_client: &RpcClient,
+    config: &CliConfig,
+    lamports: u64,
+    to: &Pubkey,
+    from: Option<&SigningAuthority>,
+    sign_only: bool,
+    signers: Option<&Vec<(Pubkey, Signature)>>,
+    blockhash_query: &BlockhashQuery,
+    nonce_account: Option<&Pubkey>,
+    nonce_authority: Option<&SigningAuthority>,
+    fee_payer: Option<&SigningAuthority>,
+) -> ProcessResult {
+    let from = from.map(|f| f.keypair()).unwrap_or(&config.keypair);
+
+    check_unique_pubkeys(
+        (&from.pubkey(), "cli keypair".to_string()),
+        (to, "to".to_string()),
+    )?;
+
+    let (recent_blockhash, fee_calculator) =
+        blockhash_query.get_blockhash_fee_calculator(rpc_client)?;
+    let ixs = vec![system_instruction::transfer(&from.pubkey(), to, lamports)];
+
+    let nonce_authority: &Keypair = nonce_authority
+        .map(|authority| authority.keypair())
+        .unwrap_or(&config.keypair);
+    let fee_payer = fee_payer.map(|fp| fp.keypair()).unwrap_or(&config.keypair);
+    let mut tx = if let Some(nonce_account) = &nonce_account {
+        Transaction::new_signed_with_nonce(
+            ixs,
+            Some(&fee_payer.pubkey()),
+            &[fee_payer, from, nonce_authority],
+            nonce_account,
+            &nonce_authority.pubkey(),
+            recent_blockhash,
+        )
+    } else {
+        Transaction::new_signed_with_payer(
+            ixs,
+            Some(&fee_payer.pubkey()),
+            &[fee_payer, from],
+            recent_blockhash,
+        )
+    };
+
+    if let Some(signers) = signers {
+        replace_signatures(&mut tx, &signers)?;
+    }
+
+    if sign_only {
+        return_signers(&tx)
+    } else {
+        if let Some(nonce_account) = &nonce_account {
+            let nonce_account = rpc_client.get_account(nonce_account)?;
+            check_nonce_account(&nonce_account, &nonce_authority.pubkey(), &recent_blockhash)?;
+        }
+        check_account_for_fee(
+            rpc_client,
+            &fee_payer.pubkey(),
+            &fee_calculator,
+            &tx.message,
+        )?;
+        let result = rpc_client.send_and_confirm_transaction(&mut tx, &[&config.keypair]);
+        log_instruction_custom_error::<SystemError>(result)
+    }
+}
+
 fn process_witness(
     rpc_client: &RpcClient,
     config: &CliConfig,
@@ -1739,6 +1852,29 @@ pub fn process_command(config: &CliConfig) -> ProcessResult {
         CliCommand::TimeElapsed(to, pubkey, dt) => {
             process_time_elapsed(&rpc_client, config, &to, &pubkey, *dt)
         }
+        CliCommand::Transfer {
+            lamports,
+            to,
+            ref from,
+            sign_only,
+            ref signers,
+            ref blockhash_query,
+            ref nonce_account,
+            ref nonce_authority,
+            ref fee_payer,
+        } => process_transfer(
+            &rpc_client,
+            config,
+            *lamports,
+            to,
+            from.as_ref(),
+            *sign_only,
+            signers.as_ref(),
+            blockhash_query,
+            nonce_account.as_ref(),
+            nonce_authority.as_ref(),
+            fee_payer.as_ref(),
+        ),
         // Apply witness signature to contract
         CliCommand::Witness(to, pubkey) => process_witness(&rpc_client, config, &to, &pubkey),
     }
@@ -2111,6 +2247,48 @@ pub fn app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, '
                         .help("Optional arbitrary timestamp to apply"),
                 ),
         )
+        .subcommand(
+            SubCommand::with_name("transfer")
+                .about("Transfer funds between system accounts")
+                .arg(
+                    Arg::with_name("to")
+                        .index(1)
+                        .value_name("TO PUBKEY")
+                        .takes_value(true)
+                        .required(true)
+                        .validator(is_pubkey_or_keypair)
+                        .help("The pubkey of recipient"),
+                )
+                .arg(
+                    Arg::with_name("amount")
+                        .index(2)
+                        .value_name("AMOUNT")
+                        .takes_value(true)
+                        .validator(is_amount)
+                        .required(true)
+                        .help("The amount to send (default unit SOL)"),
+                )
+                .arg(
+                    Arg::with_name("unit")
+                        .index(3)
+                        .value_name("UNIT")
+                        .takes_value(true)
+                        .possible_values(&["SOL", "lamports"])
+                        .help("Specify unit to use for request"),
+                )
+                .arg(
+                    Arg::with_name("from")
+                        .long("from")
+                        .takes_value(true)
+                        .value_name("KEYPAIR or PUBKEY")
+                        .validator(is_pubkey_or_keypair_or_ask_keyword)
+                        .help("Source account of funds (if different from client local account)"),
+                )
+                .offline_args()
+                .arg(nonce_arg())
+                .arg(nonce_authority_arg())
+                .arg(fee_payer_arg()),
+        )
         .subcommand(
             SubCommand::with_name("account")
                 .about("Show the contents of an account")
@@ -2156,7 +2334,7 @@ mod tests {
         account::Account,
         nonce_state::{Meta as NonceMeta, NonceState},
         pubkey::Pubkey,
-        signature::{read_keypair_file, write_keypair_file},
+        signature::{keypair_from_seed, read_keypair_file, write_keypair_file},
         system_program,
         transaction::TransactionError,
     };
@@ -3143,4 +3321,163 @@ mod tests {
         config.command = CliCommand::Deploy("bad/file/location.so".to_string());
         assert!(process_command(&config).is_err());
     }
+
+    #[test]
+    fn test_parse_transfer_subcommand() {
+        let test_commands = app("test", "desc", "version");
+
+        //Test Transfer Subcommand, lamports
+        let from_keypair = keypair_from_seed(&[0u8; 32]).unwrap();
+        let from_pubkey = from_keypair.pubkey();
+        let from_string = from_pubkey.to_string();
+        let to_keypair = keypair_from_seed(&[1u8; 32]).unwrap();
+        let to_pubkey = to_keypair.pubkey();
+        let to_string = to_pubkey.to_string();
+        let test_transfer = test_commands
+            .clone()
+            .get_matches_from(vec!["test", "transfer", &to_string, "42", "lamports"]);
+        assert_eq!(
+            parse_command(&test_transfer).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Transfer {
+                    lamports: 42,
+                    to: to_pubkey,
+                    from: None,
+                    sign_only: false,
+                    signers: None,
+                    blockhash_query: BlockhashQuery::All,
+                    nonce_account: None,
+                    nonce_authority: None,
+                    fee_payer: None,
+                },
+                require_keypair: true,
+            }
+        );
+
+        //Test Transfer Subcommand, SOL
+        let test_transfer = test_commands
+            .clone()
+            .get_matches_from(vec!["test", "transfer", &to_string, "42"]);
+        assert_eq!(
+            parse_command(&test_transfer).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Transfer {
+                    lamports: 42_000_000_000,
+                    to: to_pubkey,
+                    from: None,
+                    sign_only: false,
+                    signers: None,
+                    blockhash_query: BlockhashQuery::All,
+                    nonce_account: None,
+                    nonce_authority: None,
+                    fee_payer: None,
+                },
+                require_keypair: true,
+            }
+        );
+
+        //Test Transfer Subcommand, offline sign
+        let blockhash = Hash::new(&[1u8; 32]);
+        let blockhash_string = blockhash.to_string();
+        let test_transfer = test_commands.clone().get_matches_from(vec![
+            "test",
+            "transfer",
+            &to_string,
+            "42",
+            "lamports",
+            "--blockhash",
+            &blockhash_string,
+            "--sign-only",
+        ]);
+        assert_eq!(
+            parse_command(&test_transfer).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Transfer {
+                    lamports: 42,
+                    to: to_pubkey,
+                    from: None,
+                    sign_only: true,
+                    signers: None,
+                    blockhash_query: BlockhashQuery::None(blockhash, FeeCalculator::default()),
+                    nonce_account: None,
+                    nonce_authority: None,
+                    fee_payer: None,
+                },
+                require_keypair: true,
+            }
+        );
+
+        //Test Transfer Subcommand, submit offline `from`
+        let from_sig = from_keypair.sign_message(&[0u8]);
+        let from_signer = format!("{}={}", from_pubkey, from_sig);
+        let test_transfer = test_commands.clone().get_matches_from(vec![
+            "test",
+            "transfer",
+            &to_string,
+            "42",
+            "lamports",
+            "--from",
+            &from_string,
+            "--fee-payer",
+            &from_string,
+            "--signer",
+            &from_signer,
+            "--blockhash",
+            &blockhash_string,
+        ]);
+        assert_eq!(
+            parse_command(&test_transfer).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Transfer {
+                    lamports: 42,
+                    to: to_pubkey,
+                    from: Some(from_pubkey.into()),
+                    sign_only: false,
+                    signers: Some(vec![(from_pubkey, from_sig)]),
+                    blockhash_query: BlockhashQuery::FeeCalculator(blockhash),
+                    nonce_account: None,
+                    nonce_authority: None,
+                    fee_payer: Some(from_pubkey.into()),
+                },
+                require_keypair: true,
+            }
+        );
+
+        //Test Transfer Subcommand, with nonce
+        let nonce_address = Pubkey::new(&[1u8; 32]);
+        let nonce_address_string = nonce_address.to_string();
+        let nonce_authority = keypair_from_seed(&[2u8; 32]).unwrap();
+        let nonce_authority_file = make_tmp_path("nonce_authority_file");
+        write_keypair_file(&nonce_authority, &nonce_authority_file).unwrap();
+        let test_transfer = test_commands.clone().get_matches_from(vec![
+            "test",
+            "transfer",
+            &to_string,
+            "42",
+            "lamports",
+            "--blockhash",
+            &blockhash_string,
+            "--nonce",
+            &nonce_address_string,
+            "--nonce-authority",
+            &nonce_authority_file,
+        ]);
+        assert_eq!(
+            parse_command(&test_transfer).unwrap(),
+            CliCommandInfo {
+                command: CliCommand::Transfer {
+                    lamports: 42,
+                    to: to_pubkey,
+                    from: None,
+                    sign_only: false,
+                    signers: None,
+                    blockhash_query: BlockhashQuery::FeeCalculator(blockhash),
+                    nonce_account: Some(nonce_address.into()),
+                    nonce_authority: Some(read_keypair_file(&nonce_authority_file).unwrap().into()),
+                    fee_payer: None,
+                },
+                require_keypair: true,
+            }
+        );
+    }
 }

cli/tests/transfer.rs

@@ -0,0 +1,168 @@
+use solana_cli::{
+    cli::{process_command, request_and_confirm_airdrop, CliCommand, CliConfig},
+    offline::{parse_sign_only_reply_string, BlockhashQuery},
+};
+use solana_client::rpc_client::RpcClient;
+use solana_faucet::faucet::run_local_faucet;
+use solana_sdk::{
+    account_utils::StateMut,
+    fee_calculator::FeeCalculator,
+    nonce_state::NonceState,
+    pubkey::Pubkey,
+    signature::{keypair_from_seed, read_keypair_file, write_keypair, KeypairUtil},
+};
+use std::fs::remove_dir_all;
+use std::sync::mpsc::channel;
+
+#[cfg(test)]
+use solana_core::validator::new_validator_for_tests;
+use std::thread::sleep;
+use std::time::Duration;
+use tempfile::NamedTempFile;
+
+fn make_tmp_file() -> (String, NamedTempFile) {
+    let tmp_file = NamedTempFile::new().unwrap();
+    (String::from(tmp_file.path().to_str().unwrap()), tmp_file)
+}
+
+fn check_balance(expected_balance: u64, client: &RpcClient, pubkey: &Pubkey) {
+    (0..5).for_each(|tries| {
+        let balance = client.retry_get_balance(pubkey, 1).unwrap().unwrap();
+        if balance == expected_balance {
+            return;
+        }
+        if tries == 4 {
+            assert_eq!(balance, expected_balance);
+        }
+        sleep(Duration::from_millis(500));
+    });
+}
+
+#[test]
+fn test_transfer() {
+    let (server, leader_data, mint_keypair, ledger_path) = new_validator_for_tests();
+
+    let (sender, receiver) = channel();
+    run_local_faucet(mint_keypair, sender, None);
+    let faucet_addr = receiver.recv().unwrap();
+
+    let rpc_client = RpcClient::new_socket(leader_data.rpc);
+
+    let mut config = CliConfig::default();
+    config.json_rpc_url = format!("http://{}:{}", leader_data.rpc.ip(), leader_data.rpc.port());
+
+    let sender_pubkey = config.keypair.pubkey();
+    let recipient_pubkey = Pubkey::new(&[1u8; 32]);
+    println!("sender: {:?}", sender_pubkey);
+    println!("recipient: {:?}", recipient_pubkey);
+
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &sender_pubkey, 50_000).unwrap();
+    check_balance(50_000, &rpc_client, &sender_pubkey);
+    check_balance(0, &rpc_client, &recipient_pubkey);
+
+    // Plain ole transfer
+    config.command = CliCommand::Transfer {
+        lamports: 10,
+        to: recipient_pubkey,
+        from: None,
+        sign_only: false,
+        signers: None,
+        blockhash_query: BlockhashQuery::All,
+        nonce_account: None,
+        nonce_authority: None,
+        fee_payer: None,
+    };
+    process_command(&config).unwrap();
+    check_balance(49_990, &rpc_client, &sender_pubkey);
+    check_balance(10, &rpc_client, &recipient_pubkey);
+
+    let mut offline = CliConfig::default();
+    offline.json_rpc_url = String::default();
+    // Verify we cannot contact the cluster
+    offline.command = CliCommand::ClusterVersion;
+    process_command(&offline).unwrap_err();
+
+    let offline_pubkey = offline.keypair.pubkey();
+    println!("offline: {:?}", offline_pubkey);
+    request_and_confirm_airdrop(&rpc_client, &faucet_addr, &offline_pubkey, 50).unwrap();
+    check_balance(50, &rpc_client, &offline_pubkey);
+
+    // Offline transfer
+    let (blockhash, _) = rpc_client.get_recent_blockhash().unwrap();
+    offline.command = CliCommand::Transfer {
+        lamports: 10,
+        to: recipient_pubkey,
+        from: None,
+        sign_only: true,
+        signers: None,
+        blockhash_query: BlockhashQuery::None(blockhash, FeeCalculator::default()),
+        nonce_account: None,
+        nonce_authority: None,
+        fee_payer: None,
+    };
+    let sign_only_reply = process_command(&offline).unwrap();
+    let (blockhash, signers) = parse_sign_only_reply_string(&sign_only_reply);
+    config.command = CliCommand::Transfer {
+        lamports: 10,
+        to: recipient_pubkey,
+        from: Some(offline_pubkey.into()),
+        sign_only: false,
+        signers: Some(signers),
+        blockhash_query: BlockhashQuery::FeeCalculator(blockhash),
+        nonce_account: None,
+        nonce_authority: None,
+        fee_payer: Some(offline_pubkey.into()),
+    };
+    process_command(&config).unwrap();
+    check_balance(40, &rpc_client, &offline_pubkey);
+    check_balance(20, &rpc_client, &recipient_pubkey);
+
+    // Create nonce account
+    let nonce_account = keypair_from_seed(&[3u8; 32]).unwrap();
+    let (nonce_account_file, mut tmp_file) = make_tmp_file();
+    write_keypair(&nonce_account, tmp_file.as_file_mut()).unwrap();
+    let minimum_nonce_balance = rpc_client
+        .get_minimum_balance_for_rent_exemption(NonceState::size())
+        .unwrap();
+    config.command = CliCommand::CreateNonceAccount {
+        nonce_account: read_keypair_file(&nonce_account_file).unwrap().into(),
+        seed: None,
+        nonce_authority: None,
+        lamports: minimum_nonce_balance,
+    };
+    process_command(&config).unwrap();
+
+    // Fetch nonce hash
+    let account = rpc_client.get_account(&nonce_account.pubkey()).unwrap();
+    let nonce_state: NonceState = account.state().unwrap();
+    let nonce_hash = match nonce_state {
+        NonceState::Initialized(_meta, hash) => hash,
+        _ => panic!("Nonce is not initialized"),
+    };
+
+    // Nonced transfer
+    config.command = CliCommand::Transfer {
+        lamports: 10,
+        to: recipient_pubkey,
+        from: None,
+        sign_only: false,
+        signers: None,
+        blockhash_query: BlockhashQuery::FeeCalculator(nonce_hash),
+        nonce_account: Some(nonce_account.pubkey()),
+        nonce_authority: None,
+        fee_payer: None,
+    };
+    process_command(&config).unwrap();
+    check_balance(49_980 - minimum_nonce_balance, &rpc_client, &sender_pubkey);
+    check_balance(30, &rpc_client, &recipient_pubkey);
+    let account = rpc_client.get_account(&nonce_account.pubkey()).unwrap();
+    let nonce_state: NonceState = account.state().unwrap();
+    let new_nonce_hash = match nonce_state {
+        NonceState::Initialized(_meta, hash) => hash,
+        _ => panic!("Nonce is not initialized"),
+    };
+    assert_ne!(nonce_hash, new_nonce_hash);
+
+    server.close().unwrap();
+    remove_dir_all(ledger_path).unwrap();
+}