refactor: update upd_price.rs to use send_message_to_message_buffer f…

…unction

program/rust/src/processor/upd_price.rs

@@ -18,19 +18,16 @@ use {
             get_status_for_conf_price_ratio,
             is_component_update,
             pyth_assert,
+            send_message_to_message_buffer,
             try_convert,
+            MessageBufferAccounts,
         },
         OracleError,
     },
     solana_program::{
         account_info::AccountInfo,
         clock::Clock,
         entrypoint::ProgramResult,
-        instruction::{
-            AccountMeta,
-            Instruction,
-        },
-        program::invoke_signed,
         program_error::ProgramError,
         program_memory::sol_memcmp,
         pubkey::Pubkey,
@@ -202,60 +199,22 @@ pub fn upd_price(
     {
         if let Some(accumulator_accounts) = maybe_accumulator_accounts {
             if price_data.message_sent_ == 0 {
-                // Check that the oracle PDA is correctly configured for the program we are calling.
-                let oracle_auth_seeds: &[&[u8]] = &[
-                    UPD_PRICE_WRITE_SEED.as_bytes(),
-                    &accumulator_accounts.program_id.key.to_bytes(),
-                ];
-                let (expected_oracle_auth_pda, bump) =
-                    Pubkey::find_program_address(oracle_auth_seeds, program_id);
-                pyth_assert(
-                    expected_oracle_auth_pda == *accumulator_accounts.oracle_auth_pda.key,
-                    OracleError::InvalidPda.into(),
-                )?;
-
-                let account_metas = vec![
-                    AccountMeta {
-                        pubkey:      *accumulator_accounts.whitelist.key,
-                        is_signer:   false,
-                        is_writable: false,
-                    },
-                    AccountMeta {
-                        pubkey:      *accumulator_accounts.oracle_auth_pda.key,
-                        is_signer:   true,
-                        is_writable: false,
-                    },
-                    AccountMeta {
-                        pubkey:      *accumulator_accounts.message_buffer_data.key,
-                        is_signer:   false,
-                        is_writable: true,
-                    },
-                ];
-
                 let message = vec![
                     price_data
                         .as_price_feed_message(price_account.key)
                         .to_bytes(),
                     price_data.as_twap_message(price_account.key).to_bytes(),
                 ];
 
-                // Append a TWAP message if available
-
-                // anchor discriminator for "global:put_all"
-                let discriminator: [u8; 8] = [212, 225, 193, 91, 151, 238, 20, 93];
-                let create_inputs_ix = Instruction::new_with_borsh(
-                    *accumulator_accounts.program_id.key,
-                    &(discriminator, price_account.key.to_bytes(), message),
-                    account_metas,
-                );
-
-                let auth_seeds_with_bump: &[&[u8]] = &[
-                    UPD_PRICE_WRITE_SEED.as_bytes(),
-                    &accumulator_accounts.program_id.key.to_bytes(),
-                    &[bump],
-                ];
+                send_message_to_message_buffer(
+                    program_id,
+                    price_account.key,
+                    UPD_PRICE_WRITE_SEED,
+                    accounts,
+                    accumulator_accounts,
+                    message,
+                )?;
 
-                invoke_signed(&create_inputs_ix, accounts, &[auth_seeds_with_bump])?;
                 price_data.message_sent_ = 1;
             }
         }
@@ -322,15 +281,6 @@ fn find_publisher_index(comps: &[PriceComponent], key: &Pubkey) -> Option<usize>
     binary_search_result
 }
 
-#[allow(dead_code)]
-// Wrapper struct for the accounts required to add data to the accumulator program.
-struct MessageBufferAccounts<'a, 'b: 'a> {
-    program_id:          &'a AccountInfo<'b>,
-    whitelist:           &'a AccountInfo<'b>,
-    oracle_auth_pda:     &'a AccountInfo<'b>,
-    message_buffer_data: &'a AccountInfo<'b>,
-}
-
 #[cfg(test)]
 mod test {
     use {

program/rust/src/utils.rs

@@ -28,7 +28,14 @@ use {
     solana_program::{
         account_info::AccountInfo,
         bpf_loader_upgradeable,
-        program::invoke,
+        instruction::{
+            AccountMeta,
+            Instruction,
+        },
+        program::{
+            invoke,
+            invoke_signed,
+        },
         program_error::ProgramError,
         pubkey::Pubkey,
         system_instruction::transfer,
@@ -258,3 +265,70 @@ pub fn send_lamports<'a>(
     )?;
     Ok(())
 }
+
+// Wrapper struct for the accounts required to add data to the accumulator program.
+pub struct MessageBufferAccounts<'a, 'b: 'a> {
+    pub program_id:          &'a AccountInfo<'b>,
+    pub whitelist:           &'a AccountInfo<'b>,
+    pub oracle_auth_pda:     &'a AccountInfo<'b>,
+    pub message_buffer_data: &'a AccountInfo<'b>,
+}
+
+pub fn send_message_to_message_buffer(
+    program_id: &Pubkey,
+    base_account_key: &Pubkey,
+    seed: &str,
+    accounts: &[AccountInfo],
+    accumulator_accounts: MessageBufferAccounts,
+    message: Vec<Vec<u8>>,
+) -> Result<(), ProgramError> {
+    let account_metas = vec![
+        AccountMeta {
+            pubkey:      *accumulator_accounts.whitelist.key,
+            is_signer:   false,
+            is_writable: false,
+        },
+        AccountMeta {
+            pubkey:      *accumulator_accounts.oracle_auth_pda.key,
+            is_signer:   true,
+            is_writable: false,
+        },
+        AccountMeta {
+            pubkey:      *accumulator_accounts.message_buffer_data.key,
+            is_signer:   false,
+            is_writable: true,
+        },
+    ];
+
+    // Check that the oracle PDA is correctly configured for the program we are calling.
+    let oracle_auth_seeds: &[&[u8]] = &[
+        seed.as_bytes(),
+        &accumulator_accounts.program_id.key.to_bytes(),
+    ];
+    let (expected_oracle_auth_pda, bump) =
+        Pubkey::find_program_address(oracle_auth_seeds, program_id);
+    pyth_assert(
+        expected_oracle_auth_pda == *accumulator_accounts.oracle_auth_pda.key,
+        OracleError::InvalidPda.into(),
+    )?;
+
+    // Append a TWAP message if available
+
+    // anchor discriminator for "global:put_all"
+    let discriminator: [u8; 8] = [212, 225, 193, 91, 151, 238, 20, 93];
+    let create_inputs_ix = Instruction::new_with_borsh(
+        *accumulator_accounts.program_id.key,
+        &(discriminator, base_account_key.to_bytes(), message),
+        account_metas,
+    );
+
+    let auth_seeds_with_bump: &[&[u8]] = &[
+        seed.as_bytes(),
+        &accumulator_accounts.program_id.key.to_bytes(),
+        &[bump],
+    ];
+
+    invoke_signed(&create_inputs_ix, accounts, &[auth_seeds_with_bump])?;
+
+    Ok(())
+}