Move to utils (#247)

* moved helpers out of rust oacle

* renamed method that has same name as a solana method

Author: majabbour

program/rust/src/deserialize.rs

@@ -6,14 +6,22 @@ use bytemuck::{
     Pod,
 };
 
+use crate::c_oracle_header::{
+    pc_acc,
+    PythAccount,
+    PC_MAGIC,
+};
+use crate::utils::{
+    clear_account,
+    pyth_assert,
+};
+use solana_program::account_info::AccountInfo;
+use solana_program::program_error::ProgramError;
 use std::cell::{
     Ref,
     RefMut,
 };
 
-use solana_program::account_info::AccountInfo;
-use solana_program::program_error::ProgramError;
-
 /// Interpret the bytes in `data` as a value of type `T`
 pub fn load<T: Pod>(data: &[u8]) -> Result<&T, ProgramError> {
     try_from_bytes(
@@ -53,3 +61,37 @@ pub fn load_account_as_mut<'a, T: Pod>(
         bytemuck::from_bytes_mut(&mut data[0..size_of::<T>()])
     }))
 }
+
+pub fn load_checked<'a, T: PythAccount>(
+    account: &'a AccountInfo,
+    version: u32,
+) -> Result<RefMut<'a, T>, ProgramError> {
+    {
+        let account_header = load_account_as::<pc_acc>(account)?;
+        pyth_assert(
+            account_header.magic_ == PC_MAGIC
+                && account_header.ver_ == version
+                && account_header.type_ == T::ACCOUNT_TYPE,
+            ProgramError::InvalidArgument,
+        )?;
+    }
+
+    load_account_as_mut::<T>(account)
+}
+
+pub fn initialize_pyth_account_checked<'a, T: PythAccount>(
+    account: &'a AccountInfo,
+    version: u32,
+) -> Result<RefMut<'a, T>, ProgramError> {
+    clear_account(account)?;
+
+    {
+        let mut account_header = load_account_as_mut::<pc_acc>(account)?;
+        account_header.magic_ = PC_MAGIC;
+        account_header.ver_ = version;
+        account_header.type_ = T::ACCOUNT_TYPE;
+        account_header.size_ = T::INITIAL_SIZE;
+    }
+
+    load_account_as_mut::<T>(account)
+}

program/rust/src/rust_oracle.rs

@@ -1,5 +1,3 @@
-use std::borrow::BorrowMut;
-use std::cell::RefMut;
 use std::mem::{
     size_of,
     size_of_val,
@@ -34,33 +32,42 @@ use crate::c_oracle_header::{
     cmd_init_price_t,
     cmd_set_min_pub_t,
     cmd_upd_product_t,
-    pc_acc,
     pc_ema_t,
     pc_map_table_t,
     pc_price_comp,
     pc_price_info_t,
     pc_price_t,
     pc_prod_t,
     pc_pub_key_t,
-    PythAccount,
     PC_COMP_SIZE,
-    PC_MAGIC,
     PC_MAP_TABLE_SIZE,
-    PC_MAX_NUM_DECIMALS,
     PC_PROD_ACC_SIZE,
     PC_PTYPE_UNKNOWN,
     PC_VERSION,
     SUCCESSFULLY_UPDATED_AGGREGATE,
 };
 use crate::deserialize::{
+    initialize_pyth_account_checked, /* TODO: This has a confusingly similar name to a Solana
+                                      * sdk function */
     load,
-    load_account_as,
     load_account_as_mut,
+    load_checked,
 };
 use crate::error::OracleResult;
 use crate::OracleError;
 
-use crate::utils::pyth_assert;
+use crate::utils::{
+    check_exponent_range,
+    check_valid_fresh_account,
+    check_valid_funding_account,
+    check_valid_signable_account,
+    pubkey_assign,
+    pubkey_equal,
+    pubkey_is_zero,
+    pyth_assert,
+    read_pc_str_t,
+    try_convert,
+};
 
 use super::c_entrypoint_wrapper;
 const PRICE_T_SIZE: usize = size_of::<pc_price_t>();
@@ -187,7 +194,7 @@ pub fn init_mapping(
 
     // Initialize by setting to zero again (just in case) and populating the account header
     let hdr = load::<cmd_hdr_t>(instruction_data)?;
-    initialize_checked::<pc_map_table_t>(fresh_mapping_account, hdr.ver_)?;
+    initialize_pyth_account_checked::<pc_map_table_t>(fresh_mapping_account, hdr.ver_)?;
 
     Ok(SUCCESS)
 }
@@ -214,7 +221,7 @@ pub fn add_mapping(
         ProgramError::InvalidArgument,
     )?;
 
-    initialize_checked::<pc_map_table_t>(next_mapping, hdr.ver_)?;
+    initialize_pyth_account_checked::<pc_map_table_t>(next_mapping, hdr.ver_)?;
     pubkey_assign(&mut cur_mapping.next_, &next_mapping.key.to_bytes());
 
     Ok(SUCCESS)
@@ -250,7 +257,8 @@ pub fn add_price(
 
     let mut product_data = load_checked::<pc_prod_t>(product_account, cmd_args.ver_)?;
 
-    let mut price_data = initialize_checked::<pc_price_t>(price_account, cmd_args.ver_)?;
+    let mut price_data =
+        initialize_pyth_account_checked::<pc_price_t>(price_account, cmd_args.ver_)?;
     price_data.expo_ = cmd_args.expo_;
     price_data.ptype_ = cmd_args.ptype_;
     pubkey_assign(&mut price_data.prod_, &product_account.key.to_bytes());
@@ -450,7 +458,7 @@ pub fn add_product(
         ProgramError::InvalidArgument,
     )?;
 
-    initialize_checked::<pc_prod_t>(new_product_account, hdr.ver_)?;
+    initialize_pyth_account_checked::<pc_prod_t>(new_product_account, hdr.ver_)?;
 
     let current_index: usize = try_convert(mapping_data.num_)?;
     pubkey_assign(
@@ -550,136 +558,3 @@ pub fn set_min_pub(
 
     Ok(SUCCESS)
 }
-
-fn valid_funding_account(account: &AccountInfo) -> bool {
-    account.is_signer && account.is_writable
-}
-
-fn check_valid_funding_account(account: &AccountInfo) -> Result<(), ProgramError> {
-    pyth_assert(
-        valid_funding_account(account),
-        OracleError::InvalidFundingAccount.into(),
-    )
-}
-
-fn valid_signable_account(program_id: &Pubkey, account: &AccountInfo, minimum_size: usize) -> bool {
-    account.is_signer
-        && account.is_writable
-        && account.owner == program_id
-        && account.data_len() >= minimum_size
-        && Rent::default().is_exempt(account.lamports(), account.data_len())
-}
-
-fn check_valid_signable_account(
-    program_id: &Pubkey,
-    account: &AccountInfo,
-    minimum_size: usize,
-) -> Result<(), ProgramError> {
-    pyth_assert(
-        valid_signable_account(program_id, account, minimum_size),
-        OracleError::InvalidSignableAccount.into(),
-    )
-}
-
-/// Returns `true` if the `account` is fresh, i.e., its data can be overwritten.
-/// Use this check to prevent accidentally overwriting accounts whose data is already populated.
-fn valid_fresh_account(account: &AccountInfo) -> bool {
-    let pyth_acc = load_account_as::<pc_acc>(account);
-    match pyth_acc {
-        Ok(pyth_acc) => pyth_acc.magic_ == 0 && pyth_acc.ver_ == 0,
-        Err(_) => false,
-    }
-}
-
-fn check_valid_fresh_account(account: &AccountInfo) -> Result<(), ProgramError> {
-    pyth_assert(
-        valid_fresh_account(account),
-        OracleError::InvalidFreshAccount.into(),
-    )
-}
-
-// Check that an exponent is within the range of permitted exponents for price accounts.
-fn check_exponent_range(expo: i32) -> Result<(), ProgramError> {
-    pyth_assert(
-        expo >= -(PC_MAX_NUM_DECIMALS as i32) && expo <= PC_MAX_NUM_DECIMALS as i32,
-        ProgramError::InvalidArgument,
-    )
-}
-
-/// Sets the data of account to all-zero
-pub fn clear_account(account: &AccountInfo) -> Result<(), ProgramError> {
-    let mut data = account
-        .try_borrow_mut_data()
-        .map_err(|_| ProgramError::InvalidArgument)?;
-    let length = data.len();
-    sol_memset(data.borrow_mut(), 0, length);
-    Ok(())
-}
-
-pub fn load_checked<'a, T: PythAccount>(
-    account: &'a AccountInfo,
-    version: u32,
-) -> Result<RefMut<'a, T>, ProgramError> {
-    {
-        let account_header = load_account_as::<pc_acc>(account)?;
-        pyth_assert(
-            account_header.magic_ == PC_MAGIC
-                && account_header.ver_ == version
-                && account_header.type_ == T::ACCOUNT_TYPE,
-            ProgramError::InvalidArgument,
-        )?;
-    }
-
-    load_account_as_mut::<T>(account)
-}
-
-pub fn initialize_checked<'a, T: PythAccount>(
-    account: &'a AccountInfo,
-    version: u32,
-) -> Result<RefMut<'a, T>, ProgramError> {
-    clear_account(account)?;
-
-    {
-        let mut account_header = load_account_as_mut::<pc_acc>(account)?;
-        account_header.magic_ = PC_MAGIC;
-        account_header.ver_ = version;
-        account_header.type_ = T::ACCOUNT_TYPE;
-        account_header.size_ = T::INITIAL_SIZE;
-    }
-
-    load_account_as_mut::<T>(account)
-}
-
-// Assign pubkey bytes from source to target, fails if source is not 32 bytes
-pub fn pubkey_assign(target: &mut pc_pub_key_t, source: &[u8]) {
-    unsafe { target.k1_.copy_from_slice(source) }
-}
-
-pub fn pubkey_is_zero(key: &pc_pub_key_t) -> bool {
-    return unsafe { key.k8_.iter().all(|x| *x == 0) };
-}
-
-pub fn pubkey_equal(target: &pc_pub_key_t, source: &[u8]) -> bool {
-    unsafe { target.k1_ == *source }
-}
-
-/// Convert `x: T` into a `U`, returning the appropriate `OracleError` if the conversion fails.
-pub fn try_convert<T, U: TryFrom<T>>(x: T) -> Result<U, OracleError> {
-    // Note: the error here assumes we're only applying this function to integers right now.
-    U::try_from(x).map_err(|_| OracleError::IntegerCastingError)
-}
-
-/// Read a `pc_str_t` from the beginning of `source`. Returns a slice of `source` containing
-/// the bytes of the `pc_str_t`.
-pub fn read_pc_str_t(source: &[u8]) -> Result<&[u8], ProgramError> {
-    if source.is_empty() {
-        Err(ProgramError::InvalidArgument)
-    } else {
-        let tag_len: usize = try_convert(source[0])?;
-        if tag_len + 1 > source.len() {
-            Err(ProgramError::InvalidArgument)
-        } else {
-            Ok(&source[..(1 + tag_len)])
-        }
-    }
-}

program/rust/src/tests/test_add_mapping.rs

@@ -6,17 +6,20 @@ use crate::c_oracle_header::{
     PC_MAP_TABLE_SIZE,
     PC_VERSION,
 };
-use crate::deserialize::load_account_as_mut;
-use crate::rust_oracle::{
-    add_mapping,
-    clear_account,
-    initialize_checked,
+use crate::deserialize::{
+    initialize_pyth_account_checked,
+    load_account_as_mut,
     load_checked,
+};
+
+use crate::rust_oracle::add_mapping;
+use crate::tests::test_utils::AccountSetup;
+use crate::utils::{
+    clear_account,
     pubkey_assign,
     pubkey_equal,
     pubkey_is_zero,
 };
-use crate::tests::test_utils::AccountSetup;
 use bytemuck::bytes_of;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
@@ -36,7 +39,7 @@ fn test_add_mapping() {
 
     let mut curr_mapping_setup = AccountSetup::new::<pc_map_table_t>(&program_id);
     let cur_mapping = curr_mapping_setup.to_account_info();
-    initialize_checked::<pc_map_table_t>(&cur_mapping, PC_VERSION).unwrap();
+    initialize_pyth_account_checked::<pc_map_table_t>(&cur_mapping, PC_VERSION).unwrap();
 
     let mut next_mapping_setup = AccountSetup::new::<pc_map_table_t>(&program_id);
     let next_mapping = next_mapping_setup.to_account_info();

program/rust/src/tests/test_add_price.rs

@@ -14,12 +14,16 @@ use crate::c_oracle_header::{
     pc_prod_t,
     PC_VERSION,
 };
+use crate::deserialize::{
+    initialize_pyth_account_checked,
+    load_checked,
+};
 use crate::rust_oracle::{
     add_price,
     add_product,
+};
+use crate::utils::{
     clear_account,
-    initialize_checked,
-    load_checked,
     pubkey_equal,
     pubkey_is_zero,
 };
@@ -47,7 +51,7 @@ fn test_add_price() {
 
     let mut mapping_setup = AccountSetup::new::<pc_map_table_t>(&program_id);
     let mapping_account = mapping_setup.to_account_info();
-    initialize_checked::<pc_map_table_t>(&mapping_account, PC_VERSION).unwrap();
+    initialize_pyth_account_checked::<pc_map_table_t>(&mapping_account, PC_VERSION).unwrap();
 
     let mut product_setup = AccountSetup::new::<pc_prod_t>(&program_id);
     let product_account = product_setup.to_account_info();

program/rust/src/tests/test_add_product.rs

@@ -21,15 +21,18 @@ use crate::c_oracle_header::{
     PC_PROD_ACC_SIZE,
     PC_VERSION,
 };
-use crate::deserialize::load_account_as;
-use crate::rust_oracle::{
-    add_product,
-    clear_account,
-    initialize_checked,
+use crate::deserialize::{
+    initialize_pyth_account_checked,
+    load_account_as,
     load_checked,
+};
+use crate::utils::{
+    clear_account,
     pubkey_equal,
 };
 
+use crate::rust_oracle::add_product;
+
 #[test]
 fn test_add_product() {
     let hdr = cmd_hdr_t {
@@ -45,7 +48,7 @@ fn test_add_product() {
 
     let mut mapping_setup = AccountSetup::new::<pc_map_table_t>(&program_id);
     let mapping_account = mapping_setup.to_account_info();
-    initialize_checked::<pc_map_table_t>(&mapping_account, PC_VERSION).unwrap();
+    initialize_pyth_account_checked::<pc_map_table_t>(&mapping_account, PC_VERSION).unwrap();
 
     let mut product_setup = AccountSetup::new::<pc_prod_t>(&program_id);
     let product_account = product_setup.to_account_info();
@@ -129,7 +132,7 @@ fn test_add_product() {
 
     // test fill up of mapping table
     clear_account(&mapping_account).unwrap();
-    initialize_checked::<pc_map_table_t>(&mapping_account, PC_VERSION).unwrap();
+    initialize_pyth_account_checked::<pc_map_table_t>(&mapping_account, PC_VERSION).unwrap();
 
     for i in 0..PC_MAP_TABLE_SIZE {
         clear_account(&product_account).unwrap();