solana_nonce_account/

lib.rs

//! Functions related to nonce accounts.
#![cfg_attr(docsrs, feature(doc_cfg))]

// Imported anonymously: either name would be wrong under the other feature, and both in
// scope at once makes `state` ambiguous.
#[cfg(all(feature = "bincode", not(feature = "wincode")))]
use solana_account::state_traits::StateMut as _;
#[cfg(feature = "wincode")]
use solana_account::state_traits::StateMutWincode as _;
use {
    solana_account::{AccountSharedData, ReadableAccount},
    solana_nonce::state::State,
    solana_sdk_ids::system_program,
};
#[cfg(any(feature = "bincode", feature = "wincode"))]
use {
    solana_hash::Hash,
    solana_nonce::{state::Data, versions::Versions},
    std::cell::RefCell,
};

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn create_account(lamports: u64) -> RefCell<AccountSharedData> {
    // bincode's `new_data_with_space` is inherent while wincode's is a trait method, so this
    // shadows to bincode whenever that codec is compiled in. The encodings agree.
    RefCell::new(
        AccountSharedData::new_data_with_space(
            lamports,
            &Versions::new(State::Uninitialized),
            State::size(),
            &system_program::id(),
        )
        .expect("nonce_account"),
    )
}

/// Checks if the recent_blockhash field in Transaction verifies, and returns
/// nonce account data if so.
#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn verify_nonce_account(
    account: &AccountSharedData,
    recent_blockhash: &Hash, // Transaction.message.recent_blockhash
) -> Option<Data> {
    (account.owner() == &system_program::id())
        .then(|| {
            let versions: Versions = account.state().ok()?;
            versions.verify_recent_blockhash(recent_blockhash).cloned()
        })
        .flatten()
}

#[cfg(any(feature = "bincode", feature = "wincode"))]
pub fn lamports_per_signature_of(account: &AccountSharedData) -> Option<u64> {
    let versions: Versions = account.state().ok()?;
    match versions.state() {
        State::Initialized(data) => Some(data.fee_calculator.lamports_per_signature),
        State::Uninitialized => None,
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum SystemAccountKind {
    System,
    Nonce,
}

pub fn get_system_account_kind(account: &AccountSharedData) -> Option<SystemAccountKind> {
    if !system_program::check_id(account.owner()) {
        return None;
    }

    let data = account.data();

    if data.is_empty() {
        Some(SystemAccountKind::System)
    } else if data.len() == State::size() {
        const NONCE_VERSIONS_LEGACY: u32 = 0;
        const NONCE_VERSIONS_CURRENT: u32 = 1;
        const NONCE_STATE_INITIALIZED: u32 = 1;

        let versions_tag = u32::from_le_bytes(data.get(..4)?.try_into().ok()?);
        let state_tag = u32::from_le_bytes(data.get(4..8)?.try_into().ok()?);

        match (versions_tag, state_tag) {
            (NONCE_VERSIONS_LEGACY, NONCE_STATE_INITIALIZED) => Some(SystemAccountKind::Nonce),
            (NONCE_VERSIONS_CURRENT, NONCE_STATE_INITIALIZED) => Some(SystemAccountKind::Nonce),
            _ => None,
        }
    } else {
        None
    }
}

#[cfg(test)]
mod tests {
    use {
        super::*,
        solana_nonce::{state::Data, versions::Versions},
        solana_pubkey::Pubkey,
    };
    #[cfg(any(feature = "bincode", feature = "wincode"))]
    use {solana_fee_calculator::FeeCalculator, solana_nonce::state::DurableNonce};

    // Written by bincode, always compiled in for tests; read back through the active codec.
    #[cfg(any(feature = "bincode", feature = "wincode"))]
    #[test]
    fn test_create_account() {
        let account = create_account(42);
        let account = account.borrow();
        assert_eq!(account.lamports(), 42);
        assert_eq!(account.owner(), &system_program::id());
        assert_eq!(account.data().len(), State::size());
        let versions: Versions = account.state().unwrap();
        assert_eq!(versions.state(), &State::Uninitialized);
    }

    #[cfg(any(feature = "bincode", feature = "wincode"))]
    #[test]
    fn test_verify_bad_account_owner_fails() {
        let program_id = Pubkey::new_unique();
        assert_ne!(program_id, system_program::id());
        let account = AccountSharedData::new_data_with_space(
            42,
            &Versions::new(State::Uninitialized),
            State::size(),
            &program_id,
        )
        .expect("nonce_account");
        assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
    }

    #[cfg(any(feature = "bincode", feature = "wincode"))]
    fn new_nonce_account(versions: Versions) -> AccountSharedData {
        AccountSharedData::new_data(
            1_000_000,             // lamports
            &versions,             // state
            &system_program::id(), // owner
        )
        .unwrap()
    }

    #[cfg(any(feature = "bincode", feature = "wincode"))]
    #[test]
    fn test_verify_nonce_account() {
        let blockhash = Hash::from([171; 32]);
        let versions = Versions::Legacy(Box::new(State::Uninitialized));
        let account = new_nonce_account(versions);
        assert_eq!(verify_nonce_account(&account, &blockhash), None);
        assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
        let versions = Versions::Current(Box::new(State::Uninitialized));
        let account = new_nonce_account(versions);
        assert_eq!(verify_nonce_account(&account, &blockhash), None);
        assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
        let durable_nonce = DurableNonce::from_blockhash(&blockhash);
        let data = Data {
            authority: Pubkey::new_unique(),
            durable_nonce,
            fee_calculator: FeeCalculator {
                lamports_per_signature: 2718,
            },
        };
        let versions = Versions::Legacy(Box::new(State::Initialized(data.clone())));
        let account = new_nonce_account(versions);
        assert_eq!(verify_nonce_account(&account, &blockhash), None);
        assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
        assert_eq!(verify_nonce_account(&account, &data.blockhash()), None);
        assert_eq!(
            verify_nonce_account(&account, durable_nonce.as_hash()),
            None
        );
        let durable_nonce = DurableNonce::from_blockhash(durable_nonce.as_hash());
        assert_ne!(data.durable_nonce, durable_nonce);
        let data = Data {
            durable_nonce,
            ..data
        };
        let versions = Versions::Current(Box::new(State::Initialized(data.clone())));
        let account = new_nonce_account(versions);
        assert_eq!(verify_nonce_account(&account, &blockhash), None);
        assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
        assert_eq!(
            verify_nonce_account(&account, &data.blockhash()),
            Some(data.clone())
        );
        assert_eq!(
            verify_nonce_account(&account, durable_nonce.as_hash()),
            Some(data)
        );
    }

    #[test]
    fn test_get_system_account_kind() {
        // protect `get_system_account_kind()` against the addition of new nonce variants.
        // if anyone even attempts to add a new nonce variant however they should be punished
        fn _assert_nonce_versions(v: Versions, s: State) {
            match v {
                Versions::Legacy(..) => {}
                Versions::Current(..) => {}
            }
            match s {
                State::Uninitialized => {}
                State::Initialized(..) => {}
            }
        }

        // assert our function produces the expected result
        let assert_correct = |bytes: &[u8], kind: Option<SystemAccountKind>| {
            let mut account = AccountSharedData::new(0, 0, &system_program::id());
            account.set_data_from_slice(bytes);
            assert_eq!(get_system_account_kind(&account), kind);
        };

        // the three (unfortunately rather than two) valid fee-payer types
        let system_bytes = vec![];
        let legacy_nonce_bytes = bincode::serialize(&Versions::Legacy(Box::new(
            State::Initialized(Data::default()),
        )))
        .unwrap();
        let current_nonce_bytes = bincode::serialize(&Versions::Current(Box::new(
            State::Initialized(Data::default()),
        )))
        .unwrap();

        // success
        assert_correct(&system_bytes, Some(SystemAccountKind::System));
        assert_correct(&legacy_nonce_bytes, Some(SystemAccountKind::Nonce));
        assert_correct(&current_nonce_bytes, Some(SystemAccountKind::Nonce));

        // non-system fails
        for bytes in [&system_bytes, &legacy_nonce_bytes, &current_nonce_bytes] {
            let mut non_system = AccountSharedData::new(0, 0, &Pubkey::new_unique());
            non_system.set_data_from_slice(bytes);
            assert_eq!(get_system_account_kind(&non_system), None);
        }

        // uninitialized nonce fails
        for nonce in &[Versions::Legacy, Versions::Current] {
            let mut bytes = bincode::serialize(&nonce(Box::new(State::Uninitialized))).unwrap();
            bytes.resize(State::size(), 0);
            assert_correct(&bytes, None);
        }

        for bytes in [&legacy_nonce_bytes, &current_nonce_bytes] {
            // length too short fails
            for len in 1..bytes.len() {
                assert_correct(&bytes[..len], None);
            }

            // length too long fails
            let mut extended = bytes.clone();
            extended.push(0);
            assert_correct(&extended, None);

            // union tag variations fail
            for byte in 0..=255 {
                for i in 0..=7 {
                    // bytes would not change
                    if bytes[i] == byte {
                        continue;
                    }

                    let mut corrupted = bytes.clone();
                    corrupted[i] = byte;

                    // legacy was changed to current or vice versa
                    if corrupted == legacy_nonce_bytes || corrupted == current_nonce_bytes {
                        continue;
                    }

                    assert_correct(&corrupted, None);
                }
            }

            // data variation is ok
            for i in 8..bytes.len() {
                let mut with_data = bytes.clone();
                with_data[i] = 255;
                assert_correct(&with_data, Some(SystemAccountKind::Nonce));
            }
        }
    }
}