Traits2 (#233)

* Simplistic trait

* Remove irrelevant file

* Rename

* Delete

* Add functions to initialize tests

* Restore rust oracle

* Add comment

* Upd product uses the new syntax

* Formatted

Author: guibescos

program/rust/src/c_oracle_header.rs

@@ -16,8 +16,21 @@ include!("../bindings.rs");
 /// (mapping, price, product). This allows less duplicated code, because now we can create generic
 /// functions to perform common checks on the accounts and to load and initialize the accounts.
 pub trait PythAccount: Pod {
+    /// `ACCOUNT_TYPE` is just the account discriminator, it is different for mapping, product and
+    /// price
     const ACCOUNT_TYPE: u32;
+    /// `INITIAL_SIZE` is the value that the field `size_` will take when the account is first
+    /// initialized this one is slightly tricky because for mapping (resp. price) `size_` won't
+    /// include the unpopulated entries of `prod_` (resp. `comp_`). At the beginning there are 0
+    /// products (resp. 0 components) therefore `INITIAL_SIZE` will be equal to the offset of
+    /// `prod_` (resp. `comp_`)  Similarly the product account `INITIAL_SIZE` won't include any
+    /// key values.
     const INITIAL_SIZE: u32;
+    /// `minimum_size()` is the minimum size that the solana account holding the struct needs to
+    /// have. `INITIAL_SIZE` <= `minimum_size()`
+    fn minimum_size() -> usize {
+        size_of::<Self>()
+    }
 }
 
 impl PythAccount for pc_map_table_t {
@@ -28,6 +41,9 @@ impl PythAccount for pc_map_table_t {
 impl PythAccount for pc_prod_t {
     const ACCOUNT_TYPE: u32 = PC_ACCTYPE_PRODUCT;
     const INITIAL_SIZE: u32 = size_of::<pc_prod_t>() as u32;
+    fn minimum_size() -> usize {
+        PC_PROD_ACC_SIZE as usize
+    }
 }
 
 impl PythAccount for pc_price_t {

program/rust/src/tests/mod.rs

@@ -2,3 +2,4 @@ mod test_add_mapping;
 mod test_add_product;
 mod test_init_mapping;
 mod test_upd_product;
+mod test_utils;

program/rust/src/tests/test_add_mapping.rs

@@ -16,15 +16,10 @@ use crate::rust_oracle::{
     pubkey_equal,
     pubkey_is_zero,
 };
+use crate::tests::test_utils::AccountSetup;
 use bytemuck::bytes_of;
-use solana_program::account_info::AccountInfo;
-use solana_program::clock::Epoch;
-use solana_program::native_token::LAMPORTS_PER_SOL;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
-use solana_program::rent::Rent;
-use solana_program::system_program;
-use std::mem::size_of;
 
 #[test]
 fn test_add_mapping() {
@@ -35,61 +30,23 @@ fn test_add_mapping() {
     let instruction_data = bytes_of::<cmd_hdr_t>(&hdr);
 
     let program_id = Pubkey::new_unique();
-    let funding_key = Pubkey::new_unique();
-    let cur_mapping_key = Pubkey::new_unique();
-    let next_mapping_key = Pubkey::new_unique();
-    let system_program = system_program::id();
 
-    let mut funding_balance = LAMPORTS_PER_SOL.clone();
-    let funding_account = AccountInfo::new(
-        &funding_key,
-        true,
-        true,
-        &mut funding_balance,
-        &mut [],
-        &system_program,
-        false,
-        Epoch::default(),
-    );
-
-    let mut cur_mapping_balance =
-        Rent::minimum_balance(&Rent::default(), size_of::<pc_map_table_t>());
-    let mut cur_mapping_raw_data = [0u8; size_of::<pc_map_table_t>()];
-
-    let cur_mapping = AccountInfo::new(
-        &cur_mapping_key,
-        true,
-        true,
-        &mut cur_mapping_balance,
-        &mut cur_mapping_raw_data,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
+    let mut funding_setup = AccountSetup::new_funding();
+    let funding_account = funding_setup.to_account_info();
 
+    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();
 
+    let mut next_mapping_setup = AccountSetup::new::<pc_map_table_t>(&program_id);
+    let next_mapping = next_mapping_setup.to_account_info();
+
     {
         let mut cur_mapping_data =
             load_checked::<pc_map_table_t>(&cur_mapping, PC_VERSION).unwrap();
         cur_mapping_data.num_ = PC_MAP_TABLE_SIZE;
     }
 
-    let mut next_mapping_balance =
-        Rent::minimum_balance(&Rent::default(), size_of::<pc_map_table_t>());
-    let mut next_mapping_raw_data = [0u8; size_of::<pc_map_table_t>()];
-
-    let next_mapping = AccountInfo::new(
-        &next_mapping_key,
-        true,
-        true,
-        &mut next_mapping_balance,
-        &mut next_mapping_raw_data,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
-
     assert!(add_mapping(
         &program_id,
         &[
@@ -108,7 +65,7 @@ fn test_add_mapping() {
 
         assert!(pubkey_equal(
             &cur_mapping_data.next_,
-            &next_mapping_key.to_bytes()
+            &next_mapping.key.to_bytes()
         ));
         assert!(pubkey_is_zero(&next_mapping_data.next_));
         pubkey_assign(&mut cur_mapping_data.next_, &Pubkey::default().to_bytes());

program/rust/src/tests/test_add_product.rs

@@ -1,23 +1,18 @@
 use std::mem::size_of;
 
-use bytemuck::{
-    bytes_of,
-    Zeroable,
-};
+use crate::tests::test_utils::AccountSetup;
+use bytemuck::bytes_of;
 use solana_program::account_info::AccountInfo;
 use solana_program::clock::Epoch;
-use solana_program::native_token::LAMPORTS_PER_SOL;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
 use solana_program::rent::Rent;
-use solana_program::system_program;
 
 use crate::c_oracle_header::{
     cmd_hdr_t,
     command_t_e_cmd_add_product,
     pc_map_table_t,
     pc_prod_t,
-    PC_ACCTYPE_MAPPING,
     PC_ACCTYPE_PRODUCT,
     PC_MAGIC,
     PC_MAP_TABLE_SIZE,
@@ -42,67 +37,19 @@ fn test_add_product() {
     let instruction_data = bytes_of::<cmd_hdr_t>(&hdr);
 
     let program_id = Pubkey::new_unique();
-    let funding_key = Pubkey::new_unique();
-    let mkey = Pubkey::new_unique();
-    let product_key_1 = Pubkey::new_unique();
-    let product_key_2 = Pubkey::new_unique();
-
-    let system_program = system_program::id();
-    let mut funding_balance = LAMPORTS_PER_SOL.clone();
-    let funding_account = AccountInfo::new(
-        &funding_key,
-        true,
-        true,
-        &mut funding_balance,
-        &mut [],
-        &system_program,
-        false,
-        Epoch::default(),
-    );
 
-    let mut mapping_balance = Rent::minimum_balance(&Rent::default(), size_of::<pc_map_table_t>());
-    let mut mapping_data: pc_map_table_t = pc_map_table_t::zeroed();
-    mapping_data.magic_ = PC_MAGIC;
-    mapping_data.ver_ = PC_VERSION;
-    mapping_data.type_ = PC_ACCTYPE_MAPPING;
-    let mut mapping_bytes = bytemuck::bytes_of_mut(&mut mapping_data);
+    let mut funding_setup = AccountSetup::new_funding();
+    let funding_account = funding_setup.to_account_info();
 
-    let mapping_account = AccountInfo::new(
-        &mkey,
-        true,
-        true,
-        &mut mapping_balance,
-        &mut mapping_bytes,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
+    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();
 
-    let mut product_balance = Rent::minimum_balance(&Rent::default(), PC_PROD_ACC_SIZE as usize);
-    let mut prod_raw_data = [0u8; PC_PROD_ACC_SIZE as usize];
-    let product_account = AccountInfo::new(
-        &product_key_1,
-        true,
-        true,
-        &mut product_balance,
-        &mut prod_raw_data,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
+    let mut product_setup = AccountSetup::new::<pc_prod_t>(&program_id);
+    let product_account = product_setup.to_account_info();
 
-    let mut product_balance_2 = Rent::minimum_balance(&Rent::default(), PC_PROD_ACC_SIZE as usize);
-    let mut prod_raw_data_2 = [0u8; PC_PROD_ACC_SIZE as usize];
-    let product_account_2 = AccountInfo::new(
-        &product_key_2,
-        true,
-        true,
-        &mut product_balance_2,
-        &mut prod_raw_data_2,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
+    let mut product_setup_2 = AccountSetup::new::<pc_prod_t>(&program_id);
+    let product_account_2 = product_setup_2.to_account_info();
 
     assert!(add_product(
         &program_id,

program/rust/src/tests/test_init_mapping.rs

@@ -11,16 +11,11 @@ use crate::rust_oracle::{
     clear_account,
     init_mapping,
 };
+use crate::tests::test_utils::AccountSetup;
 use bytemuck::bytes_of;
-use solana_program::account_info::AccountInfo;
-use solana_program::clock::Epoch;
-use solana_program::native_token::LAMPORTS_PER_SOL;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
-use solana_program::rent::Rent;
-use solana_program::system_program;
 use std::cell::RefCell;
-use std::mem::size_of;
 use std::rc::Rc;
 
 #[test]
@@ -33,35 +28,12 @@ fn test_init_mapping() {
 
     let program_id = Pubkey::new_unique();
     let program_id_2 = Pubkey::new_unique();
-    let funding_key = Pubkey::new_unique();
-    let mapping_key = Pubkey::new_unique();
-    let system_program = system_program::id();
-
-    let mut funding_balance = LAMPORTS_PER_SOL.clone();
-    let mut funding_account = AccountInfo::new(
-        &funding_key,
-        true,
-        true,
-        &mut funding_balance,
-        &mut [],
-        &system_program,
-        false,
-        Epoch::default(),
-    );
 
-    let mut mapping_balance = Rent::minimum_balance(&Rent::default(), size_of::<pc_map_table_t>());
-    let mut mapping_raw_data = [0u8; size_of::<pc_map_table_t>()];
+    let mut funding_setup = AccountSetup::new_funding();
+    let mut funding_account = funding_setup.to_account_info();
 
-    let mut mapping_account = AccountInfo::new(
-        &mapping_key,
-        true,
-        true,
-        &mut mapping_balance,
-        &mut mapping_raw_data,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
+    let mut mapping_setup = AccountSetup::new::<pc_map_table_t>(&program_id);
+    let mut mapping_account = mapping_setup.to_account_info();
 
     assert!(init_mapping(
         &program_id,

program/rust/src/tests/test_upd_product.rs

@@ -1,12 +1,9 @@
 use std::mem::size_of;
 
+use crate::tests::test_utils::AccountSetup;
 use solana_program::account_info::AccountInfo;
-use solana_program::clock::Epoch;
-use solana_program::native_token::LAMPORTS_PER_SOL;
 use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
-use solana_program::rent::Rent;
-use solana_program::system_program;
 
 use crate::c_oracle_header::{
     cmd_hdr_t,
@@ -30,34 +27,12 @@ fn test_upd_product() {
     let mut instruction_data = [0u8; PC_PROD_ACC_SIZE as usize];
 
     let program_id = Pubkey::new_unique();
-    let funding_key = Pubkey::new_unique();
-    let product_key = Pubkey::new_unique();
-
-    let system_program = system_program::id();
-    let mut funding_balance = LAMPORTS_PER_SOL.clone();
-    let funding_account = AccountInfo::new(
-        &funding_key,
-        true,
-        true,
-        &mut funding_balance,
-        &mut [],
-        &system_program,
-        false,
-        Epoch::default(),
-    );
 
-    let mut product_balance = Rent::minimum_balance(&Rent::default(), PC_PROD_ACC_SIZE as usize);
-    let mut prod_raw_data = [0u8; PC_PROD_ACC_SIZE as usize];
-    let product_account = AccountInfo::new(
-        &product_key,
-        true,
-        true,
-        &mut product_balance,
-        &mut prod_raw_data,
-        &program_id,
-        false,
-        Epoch::default(),
-    );
+    let mut funding_setup = AccountSetup::new_funding();
+    let funding_account = funding_setup.to_account_info();
+
+    let mut product_setup = AccountSetup::new::<pc_prod_t>(&program_id);
+    let product_account = product_setup.to_account_info();
 
     initialize_checked::<pc_prod_t>(&product_account, PC_VERSION).unwrap();