CLI: collect and deduplicate signers (#8398)

* Rename (keypair util is not a thing) * Add method to generate_unique_signers * Cli: refactor signer handling and remote-wallet init * Fixup unit tests * Fixup intergation tests * Update keypair path print statement * Remove &None * Use deterministic key in test * Retain storage-account as index * Make signer index-handling less brittle * Cache pubkey on RemoteKeypair::new * Make signer_of consistent + return pubkey * Remove &matches double references * Nonce authorities need special handling
2020-02-24 17:03:30 -07:00
parent 89baa94002
commit 12a9b5f35e
22 changed files with 2095 additions and 1635 deletions
--- a/cli/src/nonce.rs
+++ b/cli/src/nonce.rs
@@ -1,12 +1,14 @@
 use crate::cli::{
-    build_balance_message, check_account_for_fee, check_unique_pubkeys,
+    build_balance_message, check_account_for_fee, check_unique_pubkeys, generate_unique_signers,
    log_instruction_custom_error, CliCommand, CliCommandInfo, CliConfig, CliError, ProcessResult,
+    SignerIndex,
 };
 use clap::{App, Arg, ArgMatches, SubCommand};
 use solana_clap_utils::{
    input_parsers::*, input_validators::*, offline::BLOCKHASH_ARG, ArgConstant,
 };
 use solana_client::rpc_client::RpcClient;
+use solana_remote_wallet::remote_wallet::RemoteWalletManager;
 use solana_sdk::{
    account::Account,
    account_utils::StateMut,
@@ -14,7 +16,6 @@ use solana_sdk::{
    message::Message,
    nonce_state::{Meta, NonceState},
    pubkey::Pubkey,
-    signature::Signer,
    system_instruction::{
        advance_nonce_account, authorize_nonce_account, create_address_with_seed,
        create_nonce_account, create_nonce_account_with_seed, withdraw_nonce_account, NonceError,
@@ -23,6 +24,7 @@ use solana_sdk::{
    system_program,
    transaction::Transaction,
 };
+use std::sync::Arc;

 #[derive(Debug, Clone, PartialEq)]
 pub enum CliNonceError {
@@ -216,35 +218,61 @@ impl NonceSubCommands for App<'_, '_> {
    }
 }

-pub fn parse_authorize_nonce_account(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
+pub fn parse_authorize_nonce_account(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
    let nonce_account = pubkey_of(matches, "nonce_account_keypair").unwrap();
    let new_authority = pubkey_of(matches, "new_authority").unwrap();
-    let nonce_authority = signer_of(NONCE_AUTHORITY_ARG.name, matches)?;
+    let (nonce_authority, nonce_authority_pubkey) =
+        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
+
+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, nonce_authority],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;

    Ok(CliCommandInfo {
        command: CliCommand::AuthorizeNonceAccount {
            nonce_account,
-            nonce_authority,
+            nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
            new_authority,
        },
-        require_keypair: true,
+        signers: signer_info.signers,
    })
 }

-pub fn parse_nonce_create_account(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
-    let nonce_account = signer_of("nonce_account_keypair", matches)?.unwrap();
+pub fn parse_nonce_create_account(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
+    let (nonce_account, nonce_account_pubkey) =
+        signer_of(matches, "nonce_account_keypair", wallet_manager)?;
    let seed = matches.value_of("seed").map(|s| s.to_string());
    let lamports = lamports_of_sol(matches, "amount").unwrap();
    let nonce_authority = pubkey_of(matches, NONCE_AUTHORITY_ARG.name);

+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, nonce_account],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;
+
    Ok(CliCommandInfo {
        command: CliCommand::CreateNonceAccount {
-            nonce_account: nonce_account.into(),
+            nonce_account: signer_info.index_of(nonce_account_pubkey).unwrap(),
            seed,
            nonce_authority,
            lamports,
        },
-        require_keypair: true,
+        signers: signer_info.signers,
    })
 }

@@ -253,20 +281,33 @@ pub fn parse_get_nonce(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliEr

    Ok(CliCommandInfo {
        command: CliCommand::GetNonce(nonce_account_pubkey),
-        require_keypair: false,
+        signers: vec![],
    })
 }

-pub fn parse_new_nonce(matches: &ArgMatches<'_>) -> Result<CliCommandInfo, CliError> {
+pub fn parse_new_nonce(
+    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
+) -> Result<CliCommandInfo, CliError> {
    let nonce_account = pubkey_of(matches, "nonce_account_keypair").unwrap();
-    let nonce_authority = signer_of(NONCE_AUTHORITY_ARG.name, matches)?;
+    let (nonce_authority, nonce_authority_pubkey) =
+        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
+
+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, nonce_authority],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;

    Ok(CliCommandInfo {
        command: CliCommand::NewNonce {
            nonce_account,
-            nonce_authority,
+            nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
        },
-        require_keypair: true,
+        signers: signer_info.signers,
    })
 }

@@ -279,26 +320,37 @@ pub fn parse_show_nonce_account(matches: &ArgMatches<'_>) -> Result<CliCommandIn
            nonce_account_pubkey,
            use_lamports_unit,
        },
-        require_keypair: false,
+        signers: vec![],
    })
 }

 pub fn parse_withdraw_from_nonce_account(
    matches: &ArgMatches<'_>,
+    default_signer_path: &str,
+    wallet_manager: Option<&Arc<RemoteWalletManager>>,
 ) -> Result<CliCommandInfo, CliError> {
    let nonce_account = pubkey_of(matches, "nonce_account_keypair").unwrap();
    let destination_account_pubkey = pubkey_of(matches, "destination_account_pubkey").unwrap();
    let lamports = lamports_of_sol(matches, "amount").unwrap();
-    let nonce_authority = signer_of(NONCE_AUTHORITY_ARG.name, matches)?;
+    let (nonce_authority, nonce_authority_pubkey) =
+        signer_of(matches, NONCE_AUTHORITY_ARG.name, wallet_manager)?;
+
+    let payer_provided = None;
+    let signer_info = generate_unique_signers(
+        vec![payer_provided, nonce_authority],
+        matches,
+        default_signer_path,
+        wallet_manager,
+    )?;

    Ok(CliCommandInfo {
        command: CliCommand::WithdrawFromNonceAccount {
            nonce_account,
-            nonce_authority,
+            nonce_authority: signer_info.index_of(nonce_authority_pubkey).unwrap(),
            destination_account_pubkey,
            lamports,
        },
-        require_keypair: true,
+        signers: signer_info.signers,
    })
 }

@@ -334,40 +386,36 @@ pub fn process_authorize_nonce_account(
    rpc_client: &RpcClient,
    config: &CliConfig,
    nonce_account: &Pubkey,
-    nonce_authority: Option<&dyn Signer>,
+    nonce_authority: SignerIndex,
    new_authority: &Pubkey,
 ) -> ProcessResult {
    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;

-    let nonce_authority = nonce_authority.unwrap_or_else(|| config.keypair.as_ref());
+    let nonce_authority = config.signers[nonce_authority];
    let ix = authorize_nonce_account(nonce_account, &nonce_authority.pubkey(), new_authority);
-    let message = Message::new_with_payer(vec![ix], Some(&config.keypair.pubkey()));
+    let message = Message::new_with_payer(vec![ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
-    tx.try_sign(
-        &[config.keypair.as_ref(), nonce_authority],
-        recent_blockhash,
-    )?;
+    tx.try_sign(&config.signers, recent_blockhash)?;

    check_account_for_fee(
        rpc_client,
-        &config.keypair.pubkey(),
+        &config.signers[0].pubkey(),
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client
-        .send_and_confirm_transaction(&mut tx, &[config.keypair.as_ref(), nonce_authority]);
+    let result = rpc_client.send_and_confirm_transaction(&mut tx, &config.signers);
    log_instruction_custom_error::<NonceError>(result)
 }

 pub fn process_create_nonce_account(
    rpc_client: &RpcClient,
    config: &CliConfig,
-    nonce_account: &dyn Signer,
+    nonce_account: SignerIndex,
    seed: Option<String>,
    nonce_authority: Option<Pubkey>,
    lamports: u64,
 ) -> ProcessResult {
-    let nonce_account_pubkey = nonce_account.pubkey();
+    let nonce_account_pubkey = config.signers[nonce_account].pubkey();
    let nonce_account_address = if let Some(seed) = seed.clone() {
        create_address_with_seed(&nonce_account_pubkey, &seed, &system_program::id())?
    } else {
@@ -375,7 +423,7 @@ pub fn process_create_nonce_account(
    };

    check_unique_pubkeys(
-        (&config.keypair.pubkey(), "cli keypair".to_string()),
+        (&config.signers[0].pubkey(), "cli keypair".to_string()),
        (&nonce_account_address, "nonce_account".to_string()),
    )?;

@@ -402,20 +450,20 @@ pub fn process_create_nonce_account(
        .into());
    }

-    let nonce_authority = nonce_authority.unwrap_or_else(|| config.keypair.pubkey());
+    let nonce_authority = nonce_authority.unwrap_or_else(|| config.signers[0].pubkey());

    let ixs = if let Some(seed) = seed {
        create_nonce_account_with_seed(
-            &config.keypair.pubkey(), // from
-            &nonce_account_address,   // to
-            &nonce_account_pubkey,    // base
-            &seed,                    // seed
+            &config.signers[0].pubkey(), // from
+            &nonce_account_address,      // to
+            &nonce_account_pubkey,       // base
+            &seed,                       // seed
            &nonce_authority,
            lamports,
        )
    } else {
        create_nonce_account(
-            &config.keypair.pubkey(),
+            &config.signers[0].pubkey(),
            &nonce_account_pubkey,
            &nonce_authority,
            lamports,
@@ -424,23 +472,17 @@ pub fn process_create_nonce_account(

    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;

-    let signers = if nonce_account_pubkey != config.keypair.pubkey() {
-        vec![config.keypair.as_ref(), nonce_account] // both must sign if `from` and `to` differ
-    } else {
-        vec![config.keypair.as_ref()] // when stake_account == config.keypair and there's a seed, we only need one signature
-    };
-
-    let message = Message::new_with_payer(ixs, Some(&config.keypair.pubkey()));
+    let message = Message::new_with_payer(ixs, Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
-    tx.try_sign(&signers, recent_blockhash)?;
+    tx.try_sign(&config.signers, recent_blockhash)?;

    check_account_for_fee(
        rpc_client,
-        &config.keypair.pubkey(),
+        &config.signers[0].pubkey(),
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client.send_and_confirm_transaction(&mut tx, &signers);
+    let result = rpc_client.send_and_confirm_transaction(&mut tx, &config.signers);
    log_instruction_custom_error::<SystemError>(result)
 }

@@ -468,10 +510,10 @@ pub fn process_new_nonce(
    rpc_client: &RpcClient,
    config: &CliConfig,
    nonce_account: &Pubkey,
-    nonce_authority: Option<&dyn Signer>,
+    nonce_authority: SignerIndex,
 ) -> ProcessResult {
    check_unique_pubkeys(
-        (&config.keypair.pubkey(), "cli keypair".to_string()),
+        (&config.signers[0].pubkey(), "cli keypair".to_string()),
        (&nonce_account, "nonce_account_pubkey".to_string()),
    )?;

@@ -482,23 +524,20 @@ pub fn process_new_nonce(
        .into());
    }

-    let nonce_authority = nonce_authority.unwrap_or_else(|| config.keypair.as_ref());
+    let nonce_authority = config.signers[nonce_authority];
    let ix = advance_nonce_account(&nonce_account, &nonce_authority.pubkey());
    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;
-    let message = Message::new_with_payer(vec![ix], Some(&config.keypair.pubkey()));
+    let message = Message::new_with_payer(vec![ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
-    tx.try_sign(
-        &[config.keypair.as_ref(), nonce_authority],
-        recent_blockhash,
-    )?;
+    tx.try_sign(&config.signers, recent_blockhash)?;
    check_account_for_fee(
        rpc_client,
-        &config.keypair.pubkey(),
+        &config.signers[0].pubkey(),
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client
-        .send_and_confirm_transaction(&mut tx, &[config.keypair.as_ref(), nonce_authority]);
+    let result =
+        rpc_client.send_and_confirm_transaction(&mut tx, &[config.signers[0], nonce_authority]);
    log_instruction_custom_error::<SystemError>(result)
 }

@@ -555,33 +594,29 @@ pub fn process_withdraw_from_nonce_account(
    rpc_client: &RpcClient,
    config: &CliConfig,
    nonce_account: &Pubkey,
-    nonce_authority: Option<&dyn Signer>,
+    nonce_authority: SignerIndex,
    destination_account_pubkey: &Pubkey,
    lamports: u64,
 ) -> ProcessResult {
    let (recent_blockhash, fee_calculator) = rpc_client.get_recent_blockhash()?;

-    let nonce_authority = nonce_authority.unwrap_or_else(|| config.keypair.as_ref());
+    let nonce_authority = config.signers[nonce_authority];
    let ix = withdraw_nonce_account(
        nonce_account,
        &nonce_authority.pubkey(),
        destination_account_pubkey,
        lamports,
    );
-    let message = Message::new_with_payer(vec![ix], Some(&config.keypair.pubkey()));
+    let message = Message::new_with_payer(vec![ix], Some(&config.signers[0].pubkey()));
    let mut tx = Transaction::new_unsigned(message);
-    tx.try_sign(
-        &[config.keypair.as_ref(), nonce_authority],
-        recent_blockhash,
-    )?;
+    tx.try_sign(&config.signers, recent_blockhash)?;
    check_account_for_fee(
        rpc_client,
-        &config.keypair.pubkey(),
+        &config.signers[0].pubkey(),
        &fee_calculator,
        &tx.message,
    )?;
-    let result = rpc_client
-        .send_and_confirm_transaction(&mut tx, &[config.keypair.as_ref(), nonce_authority]);
+    let result = rpc_client.send_and_confirm_transaction(&mut tx, &config.signers);
    log_instruction_custom_error::<NonceError>(result)
 }

@@ -593,10 +628,9 @@ mod tests {
        account::Account,
        hash::hash,
        nonce_state::{Meta as NonceMeta, NonceState},
-        signature::{read_keypair_file, write_keypair, Keypair},
+        signature::{read_keypair_file, write_keypair, Keypair, Signer},
        system_program,
    };
-    use std::rc::Rc;
    use tempfile::NamedTempFile;

    fn make_tmp_file() -> (String, NamedTempFile) {
@@ -607,6 +641,9 @@ mod tests {
    #[test]
    fn test_parse_command() {
        let test_commands = app("test", "desc", "version");
+        let default_keypair = Keypair::new();
+        let (default_keypair_file, mut tmp_file) = make_tmp_file();
+        write_keypair(&default_keypair, tmp_file.as_file_mut()).unwrap();
        let (keypair_file, mut tmp_file) = make_tmp_file();
        let nonce_account_keypair = Keypair::new();
        write_keypair(&nonce_account_keypair, tmp_file.as_file_mut()).unwrap();
@@ -625,14 +662,14 @@ mod tests {
            &Pubkey::default().to_string(),
        ]);
        assert_eq!(
-            parse_command(&test_authorize_nonce_account).unwrap(),
+            parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::AuthorizeNonceAccount {
                    nonce_account: nonce_account_pubkey,
-                    nonce_authority: None,
+                    nonce_authority: 0,
                    new_authority: Pubkey::default(),
                },
-                require_keypair: true,
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
            }
        );

@@ -646,16 +683,17 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(&test_authorize_nonce_account).unwrap(),
+            parse_command(&test_authorize_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::AuthorizeNonceAccount {
                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
-                    nonce_authority: Some(
-                        read_keypair_file(&authority_keypair_file).unwrap().into()
-                    ),
+                    nonce_authority: 1,
                    new_authority: Pubkey::default(),
                },
-                require_keypair: true,
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    read_keypair_file(&authority_keypair_file).unwrap().into()
+                ],
            }
        );

@@ -667,15 +705,18 @@ mod tests {
            "50",
        ]);
        assert_eq!(
-            parse_command(&test_create_nonce_account).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateNonceAccount {
-                    nonce_account: Rc::new(read_keypair_file(&keypair_file).unwrap().into()),
+                    nonce_account: 1,
                    seed: None,
                    nonce_authority: None,
                    lamports: 50_000_000_000,
                },
-                require_keypair: true
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    read_keypair_file(&keypair_file).unwrap().into()
+                ],
            }
        );

@@ -689,17 +730,18 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(&test_create_nonce_account).unwrap(),
+            parse_command(&test_create_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::CreateNonceAccount {
-                    nonce_account: Rc::new(read_keypair_file(&keypair_file).unwrap().into()),
+                    nonce_account: 1,
                    seed: None,
-                    nonce_authority: Some(
-                        read_keypair_file(&authority_keypair_file).unwrap().pubkey()
-                    ),
+                    nonce_authority: Some(nonce_authority_keypair.pubkey()),
                    lamports: 50_000_000_000,
                },
-                require_keypair: true
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    read_keypair_file(&keypair_file).unwrap().into()
+                ],
            }
        );

@@ -710,10 +752,10 @@ mod tests {
            &nonce_account_string,
        ]);
        assert_eq!(
-            parse_command(&test_get_nonce).unwrap(),
+            parse_command(&test_get_nonce, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
-                command: CliCommand::GetNonce(nonce_account_keypair.pubkey(),),
-                require_keypair: false
+                command: CliCommand::GetNonce(nonce_account_keypair.pubkey()),
+                signers: vec![],
            }
        );

@@ -724,13 +766,13 @@ mod tests {
                .get_matches_from(vec!["test", "new-nonce", &keypair_file]);
        let nonce_account = read_keypair_file(&keypair_file).unwrap();
        assert_eq!(
-            parse_command(&test_new_nonce).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::NewNonce {
                    nonce_account: nonce_account.pubkey(),
-                    nonce_authority: None,
+                    nonce_authority: 0,
                },
-                require_keypair: true
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
            }
        );

@@ -744,15 +786,16 @@ mod tests {
        ]);
        let nonce_account = read_keypair_file(&keypair_file).unwrap();
        assert_eq!(
-            parse_command(&test_new_nonce).unwrap(),
+            parse_command(&test_new_nonce, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::NewNonce {
                    nonce_account: nonce_account.pubkey(),
-                    nonce_authority: Some(
-                        read_keypair_file(&authority_keypair_file).unwrap().into()
-                    ),
+                    nonce_authority: 1,
                },
-                require_keypair: true
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    read_keypair_file(&authority_keypair_file).unwrap().into()
+                ],
            }
        );

@@ -763,13 +806,13 @@ mod tests {
            &nonce_account_string,
        ]);
        assert_eq!(
-            parse_command(&test_show_nonce_account).unwrap(),
+            parse_command(&test_show_nonce_account, &default_keypair_file, None).unwrap(),
            CliCommandInfo {
                command: CliCommand::ShowNonceAccount {
                    nonce_account_pubkey: nonce_account_keypair.pubkey(),
                    use_lamports_unit: false,
                },
-                require_keypair: false
+                signers: vec![],
            }
        );

@@ -782,15 +825,20 @@ mod tests {
            "42",
        ]);
        assert_eq!(
-            parse_command(&test_withdraw_from_nonce_account).unwrap(),
+            parse_command(
+                &test_withdraw_from_nonce_account,
+                &default_keypair_file,
+                None
+            )
+            .unwrap(),
            CliCommandInfo {
                command: CliCommand::WithdrawFromNonceAccount {
                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
-                    nonce_authority: None,
+                    nonce_authority: 0,
                    destination_account_pubkey: nonce_account_pubkey,
                    lamports: 42_000_000_000
                },
-                require_keypair: true
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
            }
        );

@@ -802,15 +850,20 @@ mod tests {
            "42",
        ]);
        assert_eq!(
-            parse_command(&test_withdraw_from_nonce_account).unwrap(),
+            parse_command(
+                &test_withdraw_from_nonce_account,
+                &default_keypair_file,
+                None
+            )
+            .unwrap(),
            CliCommandInfo {
                command: CliCommand::WithdrawFromNonceAccount {
                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
-                    nonce_authority: None,
+                    nonce_authority: 0,
                    destination_account_pubkey: nonce_account_pubkey,
                    lamports: 42000000000
                },
-                require_keypair: true
+                signers: vec![read_keypair_file(&default_keypair_file).unwrap().into()],
            }
        );

@@ -825,17 +878,23 @@ mod tests {
            &authority_keypair_file,
        ]);
        assert_eq!(
-            parse_command(&test_withdraw_from_nonce_account).unwrap(),
+            parse_command(
+                &test_withdraw_from_nonce_account,
+                &default_keypair_file,
+                None
+            )
+            .unwrap(),
            CliCommandInfo {
                command: CliCommand::WithdrawFromNonceAccount {
                    nonce_account: read_keypair_file(&keypair_file).unwrap().pubkey(),
-                    nonce_authority: Some(
-                        read_keypair_file(&authority_keypair_file).unwrap().into()
-                    ),
+                    nonce_authority: 1,
                    destination_account_pubkey: nonce_account_pubkey,
                    lamports: 42_000_000_000
                },
-                require_keypair: true
+                signers: vec![
+                    read_keypair_file(&default_keypair_file).unwrap().into(),
+                    read_keypair_file(&authority_keypair_file).unwrap().into()
+                ],
            }
        );
    }