#![deny(missing_docs)]
use solana_program::account_info::AccountInfo;
use solana_program::clock::Clock;
use solana_program::entrypoint::ProgramResult;
use solana_program::program_error::ProgramError;
use solana_program::pubkey::Pubkey;
use solana_program::sysvar::Sysvar;
use solana_program::{msg, sysvar};
use solana_sdk_ids::system_program;
#[macro_export]
macro_rules! log_everywhere {
($($arg:tt)*) => {{
let message = format!($($arg)*);
#[cfg(not(target_os = "solana"))]
{
dbg!(message);
}
#[cfg(target_os = "solana")]
{
solana_program::msg!("SOL: {}", message);
}
}}
}
pub fn check_program_account(program_id: &Pubkey, check_f: fn(&Pubkey) -> bool) -> ProgramResult {
if !&check_f(program_id) {
return Err(ProgramError::IncorrectProgramId);
}
Ok(())
}
pub fn next_optional_account_info<'a, 'b, I: Iterator<Item = &'a AccountInfo<'b>>>(
iter: &mut I,
program_id: &Pubkey,
) -> Result<Option<I::Item>, ProgramError> {
iter.next()
.ok_or(ProgramError::NotEnoughAccountKeys)
.map(|account| {
if account.key == program_id {
None
} else {
Some(account)
}
})
}
#[macro_export]
macro_rules! ensure_single_feature {
($($feature:literal),+) => {
#[cfg(not(any($(feature = $feature),+)))]
compile_error!(concat!("Exactly one of these features must be enabled: ", $(stringify!($feature), ", "),+));
ensure_single_feature!(@pairs [] $($feature),+);
};
(@pairs [$($processed:literal),*] $first:literal $(,$rest:literal)*) => {
$(
#[cfg(all(feature = $first, feature = $processed))]
compile_error!(concat!("Features '", $first, "' and '", $processed, "' are mutually exclusive"));
)*
ensure_single_feature!(@pairs [$($processed,)* $first] $($rest),*);
};
(@pairs [$($processed:literal),*]) => {};
}
#[allow(clippy::little_endian_bytes)]
pub fn checked_from_u256_le_bytes_to_u64(le_u256: &[u8; 32]) -> Result<u64, ProgramError> {
if le_u256[8..32].iter().any(|&byte| byte != 0) {
return Err(ProgramError::InvalidArgument);
}
let mut u64data: [u8; 8] = [0_u8; 8];
u64data.copy_from_slice(&le_u256[0..8]);
Ok(u64::from_le_bytes(u64data))
}
#[must_use]
#[allow(clippy::little_endian_bytes)]
pub fn from_u64_to_u256_le_bytes(u64: u64) -> [u8; 32] {
let mut u256 = [0; 32];
u256[0..8].copy_from_slice(&u64.to_le_bytes());
u256
}
pub fn current_time() -> Result<u64, ProgramError> {
let solana_now = Clock::get()?.unix_timestamp;
let now = u64::try_from(solana_now).map_err(|err| {
msg!("Cannot convert solana type into u64: {}", err);
ProgramError::InvalidArgument
})?;
Ok(now)
}
pub fn transfer_lamports(
from_account: &AccountInfo<'_>,
to_account: &AccountInfo<'_>,
amount_of_lamports: u64,
) -> ProgramResult {
if **from_account.try_borrow_lamports()? < amount_of_lamports {
return Err(ProgramError::InsufficientFunds);
}
let mut from_account = from_account.try_borrow_mut_lamports()?;
let mut to_account = to_account.try_borrow_mut_lamports()?;
**from_account = from_account
.checked_sub(amount_of_lamports)
.ok_or(ProgramError::InsufficientFunds)?;
**to_account = to_account
.checked_add(amount_of_lamports)
.ok_or(ProgramError::InsufficientFunds)?;
Ok(())
}
#[macro_export]
macro_rules! transfer_lamports_anchor {
($from:expr, $to:expr, $amount:expr) => {{
if $from.get_lamports() < $amount {
return Err(anchor_lang::error::Error::from(
anchor_lang::solana_program::program_error::ProgramError::InsufficientFunds,
));
}
$from.sub_lamports($amount)?;
$to.add_lamports($amount)?;
}};
}
pub fn validate_system_account_key(key: &Pubkey) -> Result<(), ProgramError> {
if !system_program::check_id(key) {
msg!("Wrong system account key");
return Err(ProgramError::IncorrectProgramId);
}
Ok(())
}
pub fn validate_spl_associated_token_account_key(key: &Pubkey) -> Result<(), ProgramError> {
if !spl_associated_token_account::check_id(key) {
msg!("Wrong spl associated token account key");
return Err(ProgramError::IncorrectProgramId);
}
Ok(())
}
pub fn validate_rent_key(key: &Pubkey) -> Result<(), ProgramError> {
if !sysvar::rent::check_id(key) {
msg!("Wrong rent key");
return Err(ProgramError::IncorrectProgramId);
}
Ok(())
}
pub fn validate_sysvar_instructions_key(key: &Pubkey) -> Result<(), ProgramError> {
if !sysvar::instructions::check_id(key) {
msg!("Wrong sysvar instructions key");
return Err(ProgramError::IncorrectProgramId);
}
Ok(())
}
pub fn validate_mpl_token_metadata_key(key: &Pubkey) -> Result<(), ProgramError> {
if *key != mpl_token_metadata::ID {
msg!("Wrong mpl token metadata key");
return Err(ProgramError::IncorrectProgramId);
}
Ok(())
}
#[cfg(test)]
mod tests {
#[allow(deprecated)]
use solana_program::{system_program, sysvar};
use crate::{
validate_mpl_token_metadata_key, validate_rent_key,
validate_spl_associated_token_account_key, validate_system_account_key,
validate_sysvar_instructions_key,
};
#[test]
fn validate_system_account_key_works() {
assert!(validate_system_account_key(&system_program::ID).is_ok());
assert!(validate_system_account_key(&sysvar::instructions::ID).is_err());
assert!(validate_system_account_key(&sysvar::rent::ID).is_err());
}
#[test]
fn validate_spl_associated_token_account_key_works() {
assert!(
validate_spl_associated_token_account_key(&spl_associated_token_account::ID).is_ok()
);
assert!(validate_spl_associated_token_account_key(&sysvar::instructions::ID).is_err());
assert!(validate_spl_associated_token_account_key(&sysvar::rent::ID).is_err());
}
#[test]
fn validate_rent_key_works() {
assert!(validate_rent_key(&sysvar::rent::ID).is_ok());
assert!(validate_rent_key(&system_program::ID).is_err());
assert!(validate_rent_key(&spl_associated_token_account::ID).is_err());
}
#[test]
fn sysvar_instructions_key() {
assert!(validate_sysvar_instructions_key(&sysvar::instructions::ID).is_ok());
assert!(validate_sysvar_instructions_key(&system_program::ID).is_err());
assert!(validate_sysvar_instructions_key(&spl_associated_token_account::ID).is_err());
}
#[test]
fn mpl_token_metadata_key() {
assert!(validate_mpl_token_metadata_key(&mpl_token_metadata::ID).is_ok());
assert!(validate_mpl_token_metadata_key(&system_program::ID).is_err());
assert!(validate_mpl_token_metadata_key(&spl_associated_token_account::ID).is_err());
}
}