Set min pub instruction (#235)

* working on this

* add min pub tests

* fix c code

* test initial condition

Co-authored-by: Jayant Krishnamurthy <[email protected]>

Author: jayantk

program/c/src/oracle/oracle.c

@@ -156,36 +156,6 @@ static uint64_t init_price( SolParameters *prm, SolAccountInfo *ka )
   return SUCCESS;
 }
 
-static uint64_t set_min_pub( SolParameters *prm, SolAccountInfo *ka )
-{
-  // Validate command parameters
-  cmd_set_min_pub_t *cptr = ( cmd_set_min_pub_t* )prm->data;
-  if ( prm->data_len != sizeof( cmd_set_min_pub_t ) ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // Account (1) is the price account to set min pub
-  // Verify that these are signed, writable accounts with correct ownership
-  // and size
-  if ( prm->ka_num != 2 ||
-       ! valid_funding_account( &ka[ 0 ] ) ||
-       ! valid_signable_account( prm, &ka[ 1 ], sizeof( pc_price_t ) ) ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // Verify that the price account is initialized
-  pc_price_t *sptr = ( pc_price_t* )ka[ 1 ].data;
-  if ( sptr->magic_ != PC_MAGIC ||
-       sptr->ver_ != cptr->ver_ ||
-       sptr->type_ != PC_ACCTYPE_PRICE ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  sptr->min_pub_ = cptr->min_pub_;
-
-  return SUCCESS;
-}
-
 static uint64_t add_publisher( SolParameters *prm, SolAccountInfo *ka )
 {
   // Validate command parameters
@@ -389,7 +359,7 @@ static uint64_t dispatch( SolParameters *prm, SolAccountInfo *ka )
     case e_cmd_init_price:                 return init_price( prm, ka );
     case e_cmd_init_test:                  return ERROR_INVALID_ARGUMENT;
     case e_cmd_upd_test:                   return ERROR_INVALID_ARGUMENT;
-    case e_cmd_set_min_pub:                return set_min_pub( prm, ka );
+    case e_cmd_set_min_pub:                return ERROR_INVALID_ARGUMENT;
     default:                               return ERROR_INVALID_ARGUMENT;
   }
 }

program/rust/src/c_oracle_header.rs

@@ -132,6 +132,13 @@ unsafe impl Zeroable for cmd_add_publisher_t {
 unsafe impl Pod for cmd_add_publisher_t {
 }
 
+#[cfg(target_endian = "little")]
+unsafe impl Zeroable for cmd_set_min_pub_t {
+}
+
+#[cfg(target_endian = "little")]
+unsafe impl Pod for cmd_set_min_pub_t {
+}
 
 #[cfg(target_endian = "little")]
 unsafe impl Zeroable for pc_pub_key_t {

program/rust/src/processor.rs

@@ -13,6 +13,7 @@ use crate::c_oracle_header::{
     command_t_e_cmd_add_publisher,
     command_t_e_cmd_agg_price,
     command_t_e_cmd_init_mapping,
+    command_t_e_cmd_set_min_pub,
     command_t_e_cmd_upd_account_version,
     command_t_e_cmd_upd_price,
     command_t_e_cmd_upd_price_no_fail_on_error,
@@ -30,6 +31,7 @@ use crate::rust_oracle::{
     add_product,
     add_publisher,
     init_mapping,
+    set_min_pub,
     upd_product,
     update_price,
     update_version,
@@ -72,6 +74,7 @@ pub fn process_instruction(
         command_t_e_cmd_add_publisher => add_publisher(program_id, accounts, instruction_data),
         command_t_e_cmd_add_product => add_product(program_id, accounts, instruction_data),
         command_t_e_cmd_upd_product => upd_product(program_id, accounts, instruction_data),
+        command_t_e_cmd_set_min_pub => set_min_pub(program_id, accounts, instruction_data),
         _ => c_entrypoint_wrapper(input),
     }
 }

program/rust/src/rust_oracle.rs

@@ -23,6 +23,7 @@ use crate::c_oracle_header::{
     cmd_add_price_t,
     cmd_add_publisher_t,
     cmd_hdr_t,
+    cmd_set_min_pub_t,
     cmd_upd_product_t,
     pc_acc,
     pc_map_table_t,
@@ -322,6 +323,32 @@ pub fn upd_product(
     Ok(SUCCESS)
 }
 
+pub fn set_min_pub(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> OracleResult {
+    let cmd = load::<cmd_set_min_pub_t>(instruction_data)?;
+
+    pyth_assert(
+        instruction_data.len() == size_of::<cmd_set_min_pub_t>(),
+        ProgramError::InvalidArgument,
+    )?;
+
+    let [funding_account, price_account] = match accounts {
+        [x, y] => Ok([x, y]),
+        _ => Err(ProgramError::InvalidArgument),
+    }?;
+
+    check_valid_funding_account(funding_account)?;
+    check_valid_signable_account(program_id, price_account, size_of::<pc_price_t>())?;
+
+    let mut price_account_data = load_checked::<pc_price_t>(price_account, cmd.ver_)?;
+    price_account_data.min_pub_ = cmd.min_pub_;
+
+    Ok(SUCCESS)
+}
+
 fn valid_funding_account(account: &AccountInfo) -> bool {
     account.is_signer && account.is_writable
 }

program/rust/src/tests/mod.rs

@@ -1,5 +1,6 @@
 mod test_add_mapping;
 mod test_add_product;
 mod test_init_mapping;
+mod test_set_min_pub;
 mod test_upd_product;
 mod test_utils;

program/rust/src/tests/test_set_min_pub.rs

@@ -0,0 +1,90 @@
+use std::mem::size_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_set_min_pub_t,
+    command_t_e_cmd_set_min_pub,
+    pc_price_t,
+    PC_VERSION,
+};
+use crate::deserialize::load_mut;
+use crate::rust_oracle::{
+    initialize_checked,
+    load_checked,
+    set_min_pub,
+};
+
+#[test]
+fn test_set_min_pub() {
+    let mut instruction_data = [0u8; size_of::<cmd_set_min_pub_t>()];
+
+    let program_id = Pubkey::new_unique();
+    let funding_key = Pubkey::new_unique();
+    let price_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 price_balance = Rent::minimum_balance(&Rent::default(), size_of::<pc_price_t>());
+    let mut price_raw_data = [0u8; size_of::<pc_price_t>()];
+    let price_account = AccountInfo::new(
+        &price_key,
+        true,
+        true,
+        &mut price_balance,
+        &mut price_raw_data,
+        &program_id,
+        false,
+        Epoch::default(),
+    );
+
+    initialize_checked::<pc_price_t>(&price_account, PC_VERSION).unwrap();
+    assert_eq!(get_min_pub(&price_account), Ok(0));
+
+    populate_instruction(&mut instruction_data, 10);
+    assert!(set_min_pub(
+        &program_id,
+        &[funding_account.clone(), price_account.clone()],
+        &instruction_data
+    )
+    .is_ok());
+    assert_eq!(get_min_pub(&price_account), Ok(10));
+
+    populate_instruction(&mut instruction_data, 2);
+    assert!(set_min_pub(
+        &program_id,
+        &[funding_account.clone(), price_account.clone()],
+        &instruction_data
+    )
+    .is_ok());
+    assert_eq!(get_min_pub(&price_account), Ok(2));
+}
+
+// Create an upd_product instruction that sets the product metadata to strings
+fn populate_instruction(instruction_data: &mut [u8], min_pub: u8) -> () {
+    let mut hdr = load_mut::<cmd_set_min_pub_t>(instruction_data).unwrap();
+    hdr.ver_ = PC_VERSION;
+    hdr.cmd_ = command_t_e_cmd_set_min_pub as i32;
+    hdr.min_pub_ = min_pub;
+}
+
+fn get_min_pub(account: &AccountInfo) -> Result<u8, ProgramError> {
+    Ok(load_checked::<pc_price_t>(account, PC_VERSION)?.min_pub_)
+}