Move nonce utils from runtime to sdk (bp #12577) (#12583)

* runtime: Move prepare_if_nonce_account into accounts

(cherry picked from commit caec631344)

* Move nonced tx helpers to SDK

(cherry picked from commit 65b868f4eb)

* Move remaining nonce utils from runtime to SDK

(cherry picked from commit 3c7b9c2938)

# Conflicts:
#	runtime/src/bank.rs

* Fix conflict

Co-authored-by: Trent Nelson <trent@solana.com>
Co-authored-by: Tyera Eulberg <teulberg@gmail.com>

sdk/src/nonce/mod.rs

@@ -2,3 +2,4 @@ pub mod account;
 pub use account::{create_account, Account};
 pub mod state;
 pub use state::State;
+pub mod utils;

sdk/src/nonce/utils.rs

@@ -0,0 +1,86 @@
+use solana_sdk::{
+    account::Account,
+    account_utils::StateMut,
+    fee_calculator::FeeCalculator,
+    hash::Hash,
+    nonce::{state::Versions, State},
+};
+
+pub fn verify_nonce_account(acc: &Account, hash: &Hash) -> bool {
+    match StateMut::<Versions>::state(acc).map(|v| v.convert_to_current()) {
+        Ok(State::Initialized(ref data)) => *hash == data.blockhash,
+        _ => false,
+    }
+}
+
+pub fn fee_calculator_of(account: &Account) -> Option<FeeCalculator> {
+    let state = StateMut::<Versions>::state(account)
+        .ok()?
+        .convert_to_current();
+    match state {
+        State::Initialized(data) => Some(data.fee_calculator),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use solana_sdk::{
+        account_utils::State as AccountUtilsState,
+        hash::Hash,
+        nonce::{account::with_test_keyed_account, Account as NonceAccount, State},
+        sysvar::{recent_blockhashes::create_test_recent_blockhashes, rent::Rent},
+    };
+    use std::collections::HashSet;
+
+    #[test]
+    fn verify_nonce_ok() {
+        with_test_keyed_account(42, true, |nonce_account| {
+            let mut signers = HashSet::new();
+            signers.insert(nonce_account.signer_key().unwrap());
+            let state: State = nonce_account.state().unwrap();
+            // New is in Uninitialzed state
+            assert_eq!(state, State::Uninitialized);
+            let recent_blockhashes = create_test_recent_blockhashes(0);
+            let authorized = nonce_account.unsigned_key();
+            nonce_account
+                .initialize_nonce_account(&authorized, &recent_blockhashes, &Rent::free())
+                .unwrap();
+            assert!(verify_nonce_account(
+                &nonce_account.account.borrow(),
+                &recent_blockhashes[0].blockhash,
+            ));
+        });
+    }
+
+    #[test]
+    fn verify_nonce_bad_acc_state_fail() {
+        with_test_keyed_account(42, true, |nonce_account| {
+            assert!(!verify_nonce_account(
+                &nonce_account.account.borrow(),
+                &Hash::default()
+            ));
+        });
+    }
+
+    #[test]
+    fn verify_nonce_bad_query_hash_fail() {
+        with_test_keyed_account(42, true, |nonce_account| {
+            let mut signers = HashSet::new();
+            signers.insert(nonce_account.signer_key().unwrap());
+            let state: State = nonce_account.state().unwrap();
+            // New is in Uninitialzed state
+            assert_eq!(state, State::Uninitialized);
+            let recent_blockhashes = create_test_recent_blockhashes(0);
+            let authorized = nonce_account.unsigned_key();
+            nonce_account
+                .initialize_nonce_account(&authorized, &recent_blockhashes, &Rent::free())
+                .unwrap();
+            assert!(!verify_nonce_account(
+                &nonce_account.account.borrow(),
+                &recent_blockhashes[1].blockhash,
+            ));
+        });
+    }
+}

sdk/src/transaction.rs

@@ -6,10 +6,13 @@ use crate::{
     hash::Hash,
     instruction::{CompiledInstruction, Instruction, InstructionError},
     message::Message,
+    program_utils::limited_deserialize,
     pubkey::Pubkey,
     short_vec,
     signature::{Signature, SignerError},
     signers::Signers,
+    system_instruction::SystemInstruction,
+    system_program,
 };
 use std::result;
 use thiserror::Error;
@@ -395,6 +398,31 @@ impl Transaction {
     }
 }
 
+pub fn uses_durable_nonce(tx: &Transaction) -> Option<&CompiledInstruction> {
+    let message = tx.message();
+    message
+        .instructions
+        .get(0)
+        .filter(|maybe_ix| {
+            let prog_id_idx = maybe_ix.program_id_index as usize;
+            match message.account_keys.get(prog_id_idx) {
+                Some(program_id) => system_program::check_id(&program_id),
+                _ => false,
+            }
+        } && matches!(limited_deserialize(&maybe_ix.data), Ok(SystemInstruction::AdvanceNonceAccount))
+        )
+}
+
+pub fn get_nonce_pubkey_from_instruction<'a>(
+    ix: &CompiledInstruction,
+    tx: &'a Transaction,
+) -> Option<&'a Pubkey> {
+    ix.accounts.get(0).and_then(|idx| {
+        let idx = *idx as usize;
+        tx.message().account_keys.get(idx)
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -812,4 +840,99 @@ mod tests {
             vec![Signature::default(), Signature::default()]
         );
     }
+
+    fn nonced_transfer_tx() -> (Pubkey, Pubkey, Transaction) {
+        let from_keypair = Keypair::new();
+        let from_pubkey = from_keypair.pubkey();
+        let nonce_keypair = Keypair::new();
+        let nonce_pubkey = nonce_keypair.pubkey();
+        let instructions = [
+            system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey),
+            system_instruction::transfer(&from_pubkey, &nonce_pubkey, 42),
+        ];
+        let message = Message::new(&instructions, Some(&nonce_pubkey));
+        let tx = Transaction::new(&[&from_keypair, &nonce_keypair], message, Hash::default());
+        (from_pubkey, nonce_pubkey, tx)
+    }
+
+    #[test]
+    fn tx_uses_nonce_ok() {
+        let (_, _, tx) = nonced_transfer_tx();
+        assert!(uses_durable_nonce(&tx).is_some());
+    }
+
+    #[test]
+    fn tx_uses_nonce_empty_ix_fail() {
+        assert!(uses_durable_nonce(&Transaction::default()).is_none());
+    }
+
+    #[test]
+    fn tx_uses_nonce_bad_prog_id_idx_fail() {
+        let (_, _, mut tx) = nonced_transfer_tx();
+        tx.message.instructions.get_mut(0).unwrap().program_id_index = 255u8;
+        assert!(uses_durable_nonce(&tx).is_none());
+    }
+
+    #[test]
+    fn tx_uses_nonce_first_prog_id_not_nonce_fail() {
+        let from_keypair = Keypair::new();
+        let from_pubkey = from_keypair.pubkey();
+        let nonce_keypair = Keypair::new();
+        let nonce_pubkey = nonce_keypair.pubkey();
+        let instructions = [
+            system_instruction::transfer(&from_pubkey, &nonce_pubkey, 42),
+            system_instruction::advance_nonce_account(&nonce_pubkey, &nonce_pubkey),
+        ];
+        let message = Message::new(&instructions, Some(&from_pubkey));
+        let tx = Transaction::new(&[&from_keypair, &nonce_keypair], message, Hash::default());
+        assert!(uses_durable_nonce(&tx).is_none());
+    }
+
+    #[test]
+    fn tx_uses_nonce_wrong_first_nonce_ix_fail() {
+        let from_keypair = Keypair::new();
+        let from_pubkey = from_keypair.pubkey();
+        let nonce_keypair = Keypair::new();
+        let nonce_pubkey = nonce_keypair.pubkey();
+        let instructions = [
+            system_instruction::withdraw_nonce_account(
+                &nonce_pubkey,
+                &nonce_pubkey,
+                &from_pubkey,
+                42,
+            ),
+            system_instruction::transfer(&from_pubkey, &nonce_pubkey, 42),
+        ];
+        let message = Message::new(&instructions, Some(&nonce_pubkey));
+        let tx = Transaction::new(&[&from_keypair, &nonce_keypair], message, Hash::default());
+        assert!(uses_durable_nonce(&tx).is_none());
+    }
+
+    #[test]
+    fn get_nonce_pub_from_ix_ok() {
+        let (_, nonce_pubkey, tx) = nonced_transfer_tx();
+        let nonce_ix = uses_durable_nonce(&tx).unwrap();
+        assert_eq!(
+            get_nonce_pubkey_from_instruction(&nonce_ix, &tx),
+            Some(&nonce_pubkey),
+        );
+    }
+
+    #[test]
+    fn get_nonce_pub_from_ix_no_accounts_fail() {
+        let (_, _, tx) = nonced_transfer_tx();
+        let nonce_ix = uses_durable_nonce(&tx).unwrap();
+        let mut nonce_ix = nonce_ix.clone();
+        nonce_ix.accounts.clear();
+        assert_eq!(get_nonce_pubkey_from_instruction(&nonce_ix, &tx), None,);
+    }
+
+    #[test]
+    fn get_nonce_pub_from_ix_bad_acc_idx_fail() {
+        let (_, _, tx) = nonced_transfer_tx();
+        let nonce_ix = uses_durable_nonce(&tx).unwrap();
+        let mut nonce_ix = nonce_ix.clone();
+        nonce_ix.accounts[0] = 255u8;
+        assert_eq!(get_nonce_pubkey_from_instruction(&nonce_ix, &tx), None,);
+    }
 }