Merge branch 'main' into add-price-rust

Author: guibescos

program/c/src/oracle/oracle.c

@@ -59,33 +59,6 @@ static bool valid_writable_account( SolParameters *prm,
          is_rent_exempt( *ka->lamports, ka->data_len );
 }
 
-static uint64_t init_mapping( SolParameters *prm, SolAccountInfo *ka )
-{
-  // Verify that the new account is signed and writable, with correct
-  // ownership and size
-  if ( prm->ka_num != 2 ||
-       !valid_funding_account( &ka[0] ) ||
-       !valid_signable_account( prm, &ka[1], sizeof( pc_map_table_t ) ) ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // Check that the account has not already been initialized
-  pc_map_table_t *tptr = (pc_map_table_t*)ka[1].data;
-  if ( tptr->magic_ != 0 || tptr->ver_ != 0 ) {
-    return ERROR_INVALID_ARGUMENT;
-  }
-
-  // Initialize by setting to zero again (just in case) and setting
-  // the version number
-  cmd_hdr_t *hdr = (cmd_hdr_t*)prm->data;
-  sol_memset( tptr, 0, sizeof( pc_map_table_t ) );
-  tptr->magic_ = PC_MAGIC;
-  tptr->ver_   = hdr->ver_;
-  tptr->type_  = PC_ACCTYPE_MAPPING;
-  tptr->size_  = sizeof( pc_map_table_t ) - sizeof( tptr->prod_ );
-  return SUCCESS;
-}
-
 static uint64_t add_mapping( SolParameters *prm, SolAccountInfo *ka )
 {
   // Account (1) is the tail or last mapping account in the chain
@@ -539,7 +512,7 @@ static uint64_t dispatch( SolParameters *prm, SolAccountInfo *ka )
     case e_cmd_agg_price:                  return upd_price( prm, ka );
     case e_cmd_upd_price_no_fail_on_error: return upd_price_no_fail_on_error( prm, ka );
     // init_mapping is overridden in Rust, but still implemented here to make the C unit tests pass.
-    case e_cmd_init_mapping:               return init_mapping( prm, ka );
+    case e_cmd_init_mapping:               return ERROR_INVALID_ARGUMENT;
     case e_cmd_add_mapping:                return add_mapping( prm, ka );
     case e_cmd_add_product:                return add_product( prm, ka );
     case e_cmd_upd_product:                return upd_product( prm, ka );

program/c/src/oracle/test_oracle.c

@@ -7,81 +7,6 @@ uint64_t MAPPING_ACCOUNT_LAMPORTS = 143821440;
 uint64_t PRODUCT_ACCOUNT_LAMPORTS = 4454400;
 uint64_t PRICE_ACCOUNT_LAMPORTS = 23942400;
 
-Test(oracle, init_mapping) {
-
-  // start with perfect inputs
-  cmd_hdr_t idata = {
-    .ver_ = PC_VERSION,
-    .cmd_ = e_cmd_init_mapping
-  };
-  SolPubkey p_id  = {.x = { 0xff, }};
-  SolPubkey p_id2 = {.x = { 0xfe, }};
-  SolPubkey pkey = {.x = { 1, }};
-  SolPubkey mkey = {.x = { 2, }};
-  uint64_t pqty = 100;
-  pc_map_table_t mptr[1];
-  sol_memset( mptr, 0, sizeof( pc_map_table_t ) );
-  SolAccountInfo acc[] = {{
-      .key         = &pkey,
-      .lamports    = &pqty,
-      .data_len    = 0,
-      .data        = NULL,
-      .owner       = NULL,
-      .rent_epoch  = 0,
-      .is_signer   = true,
-      .is_writable = true,
-      .executable  = false
-  },{
-      .key         = &mkey,
-      .lamports    = &MAPPING_ACCOUNT_LAMPORTS,
-      .data_len    = sizeof( pc_map_table_t ),
-      .data        = (uint8_t*)mptr,
-      .owner       = &p_id,
-      .rent_epoch  = 0,
-      .is_signer   = true,
-      .is_writable = true,
-      .executable  = false
-  }};
-  SolParameters prm = {
-    .ka         = acc,
-    .ka_num     = 2,
-    .data       = (const uint8_t*)&idata,
-    .data_len   = sizeof( idata ),
-    .program_id = &p_id
-  };
-  cr_assert( SUCCESS == dispatch( &prm, acc ) );
-  cr_assert( mptr->ver_ == PC_VERSION );
-  cr_assert( mptr->type_ == PC_ACCTYPE_MAPPING );
-
-  // cant reinitialize because version has been set
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  sol_memset( mptr, 0, sizeof( pc_map_table_t ) );
-
-  // check other params
-  prm.ka_num = 1;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  prm.ka_num = 2;
-  acc[0].is_signer = false;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  acc[0].is_signer = true;
-  acc[1].is_signer = false;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  acc[1].is_signer = true;
-  acc[0].is_writable = false;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  acc[0].is_writable = true;
-  acc[1].is_writable = false;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  acc[1].is_writable = true;
-  acc[1].owner = &p_id2;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  acc[1].owner = &p_id;
-  acc[1].data_len = 0;
-  cr_assert( ERROR_INVALID_ARGUMENT == dispatch( &prm, acc ) );
-  acc[1].data_len = sizeof( pc_map_table_t );
-  cr_assert( SUCCESS == dispatch( &prm, acc ) );
-}
-
 Test(oracle, add_mapping ) {
   // start with perfect inputs
   cmd_hdr_t idata = {

program/rust/src/lib.rs

@@ -10,7 +10,9 @@ mod error;
 mod log;
 mod processor;
 mod rust_oracle;
+mod test_oracle;
 mod time_machine_types;
+mod utils;
 
 use crate::c_oracle_header::SUCCESSFULLY_UPDATED_AGGREGATE;
 use crate::error::{

program/rust/src/processor.rs

@@ -8,6 +8,7 @@ use solana_program::sysvar::slot_history::AccountInfo;
 use crate::c_entrypoint_wrapper;
 use crate::c_oracle_header::{
     cmd_hdr,
+    command_t_e_cmd_add_mapping,
     command_t_e_cmd_add_price,
     command_t_e_cmd_agg_price,
     command_t_e_cmd_init_mapping,
@@ -21,6 +22,7 @@ use crate::error::{
     OracleResult,
 };
 use crate::rust_oracle::{
+    add_mapping,
     add_price,
     init_mapping,
     update_price,
@@ -60,6 +62,7 @@ pub fn process_instruction(
         }
         command_t_e_cmd_add_price => add_price(program_id, accounts, instruction_data),
         command_t_e_cmd_init_mapping => init_mapping(program_id, accounts, instruction_data),
+        command_t_e_cmd_add_mapping => add_mapping(program_id, accounts, instruction_data),
         _ => c_entrypoint_wrapper(input),
     }
 }

program/rust/src/rust_oracle.rs

@@ -13,12 +13,12 @@ use bytemuck::{
     try_from_bytes_mut,
     Pod,
 };
+use solana_program::account_info::AccountInfo;
 use solana_program::entrypoint::SUCCESS;
 use solana_program::program_error::ProgramError;
 use solana_program::program_memory::sol_memset;
 use solana_program::pubkey::Pubkey;
 use solana_program::rent::Rent;
-use solana_program::sysvar::slot_history::AccountInfo;
 
 use crate::c_oracle_header::{
     cmd_add_price_t,
@@ -31,12 +31,15 @@ use crate::c_oracle_header::{
     PC_ACCTYPE_PRICE,
     PC_ACCTYPE_PRODUCT,
     PC_MAGIC,
+    PC_MAP_TABLE_SIZE,
     PC_MAX_NUM_DECIMALS,
     PC_PROD_ACC_SIZE,
     PC_PTYPE_UNKNOWN,
 };
 use crate::error::OracleResult;
 
+use crate::utils::pyth_assert;
+
 use super::c_entrypoint_wrapper;
 
 ///Calls the c oracle update_price, and updates the Time Machine if needed
@@ -83,14 +86,44 @@ pub fn init_mapping(
     }?;
 
     // Initialize by setting to zero again (just in case) and populating the account header
-    clear_account(fresh_mapping_account)?;
+    let hdr = load::<cmd_hdr_t>(instruction_data)?;
+    initialize_mapping_account(fresh_mapping_account, hdr.ver_)?;
+
+    Ok(SUCCESS)
+}
+
+pub fn add_mapping(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> OracleResult {
+    let [_funding_account, cur_mapping, next_mapping] = match accounts {
+        [x, y, z]
+            if valid_funding_account(x)
+                && valid_signable_account(program_id, y, size_of::<pc_map_table_t>())
+                && valid_signable_account(program_id, z, size_of::<pc_map_table_t>())
+                && valid_fresh_account(z) =>
+        {
+            Ok([x, y, z])
+        }
+        _ => Err(ProgramError::InvalidArgument),
+    }?;
 
     let hdr = load::<cmd_hdr_t>(instruction_data)?;
-    let mut mapping_data = load_account_as_mut::<pc_map_table_t>(fresh_mapping_account)?;
-    mapping_data.magic_ = PC_MAGIC;
-    mapping_data.ver_ = hdr.ver_;
-    mapping_data.type_ = PC_ACCTYPE_MAPPING;
-    mapping_data.size_ = (size_of::<pc_map_table_t>() - size_of_val(&mapping_data.prod_)) as u32;
+    let mut cur_mapping = load_mapping_account_mut(cur_mapping, hdr.ver_)?;
+    pyth_assert(
+        cur_mapping.num_ == PC_MAP_TABLE_SIZE
+            && unsafe { cur_mapping.next_.k8_.iter().all(|x| *x == 0) },
+        ProgramError::InvalidArgument,
+    )?;
+
+    initialize_mapping_account(next_mapping, hdr.ver_)?;
+    unsafe {
+        cur_mapping
+            .next_
+            .k1_
+            .copy_from_slice(&next_mapping.key.to_bytes());
+    }
 
     Ok(SUCCESS)
 }
@@ -180,7 +213,7 @@ fn valid_fresh_account(account: &AccountInfo) -> bool {
 }
 
 /// Sets the data of account to all-zero
-fn clear_account(account: &AccountInfo) -> Result<(), ProgramError> {
+pub fn clear_account(account: &AccountInfo) -> Result<(), ProgramError> {
     let mut data = account
         .try_borrow_mut_data()
         .map_err(|_| ProgramError::InvalidArgument)?;
@@ -201,7 +234,7 @@ fn load_mut<T: Pod>(data: &mut [u8]) -> Result<&mut T, ProgramError> {
 }
 
 /// Get the data stored in `account` as a value of type `T`
-fn load_account_as<'a, T: Pod>(account: &'a AccountInfo) -> Result<Ref<'a, T>, ProgramError> {
+pub fn load_account_as<'a, T: Pod>(account: &'a AccountInfo) -> Result<Ref<'a, T>, ProgramError> {
     let data = account.try_borrow_data()?;
 
     Ok(Ref::map(data, |data| {
@@ -211,7 +244,7 @@ fn load_account_as<'a, T: Pod>(account: &'a AccountInfo) -> Result<Ref<'a, T>, P
 
 /// Mutably borrow the data in `account` as a value of type `T`.
 /// Any mutations to the returned value will be reflected in the account data.
-fn load_account_as_mut<'a, T: Pod>(
+pub fn load_account_as_mut<'a, T: Pod>(
     account: &'a AccountInfo,
 ) -> Result<RefMut<'a, T>, ProgramError> {
     let data = account.try_borrow_mut_data()?;
@@ -220,3 +253,38 @@ fn load_account_as_mut<'a, T: Pod>(
         bytemuck::from_bytes_mut(&mut data[0..size_of::<T>()])
     }))
 }
+
+/// Mutably borrow the data in `account` as a mapping account, validating that the account
+/// is properly formatted. Any mutations to the returned value will be reflected in the
+/// account data. Use this to read already-initialized accounts.
+fn load_mapping_account_mut<'a>(
+    account: &'a AccountInfo,
+    expected_version: u32,
+) -> Result<RefMut<'a, pc_map_table_t>, ProgramError> {
+    let mapping_account_ref = load_account_as_mut::<pc_map_table_t>(account)?;
+    let mapping_account = *mapping_account_ref;
+
+    pyth_assert(
+        mapping_account.magic_ == PC_MAGIC
+            && mapping_account.ver_ == expected_version
+            && mapping_account.type_ == PC_ACCTYPE_MAPPING,
+        ProgramError::InvalidArgument,
+    )?;
+
+    Ok(mapping_account_ref)
+}
+
+/// Initialize account as a new mapping account. This function will zero out any existing data in
+/// the account.
+fn initialize_mapping_account(account: &AccountInfo, version: u32) -> Result<(), ProgramError> {
+    clear_account(account)?;
+
+    let mut mapping_account = load_account_as_mut::<pc_map_table_t>(account)?;
+    mapping_account.magic_ = PC_MAGIC;
+    mapping_account.ver_ = version;
+    mapping_account.type_ = PC_ACCTYPE_MAPPING;
+    mapping_account.size_ =
+        (size_of::<pc_map_table_t>() - size_of_val(&mapping_account.prod_)) as u32;
+
+    Ok(())
+}