feat: assign price feed indexes to old accounts

Author: Riateche

program/rust/build.rs

@@ -91,8 +91,8 @@ fn do_make_build(targets: Vec<&str>, out_dir: &Path) {
             "C oracle make build did not exit with 0 (code
 	({:?}).\n\nstdout:\n{}\n\nstderr:\n{}",
             make_output.status.code(),
-            String::from_utf8(make_output.stdout).unwrap_or("<non-utf8>".to_owned()),
-            String::from_utf8(make_output.stderr).unwrap_or("<non-utf8>".to_owned())
+            String::from_utf8_lossy(&make_output.stdout),
+            String::from_utf8_lossy(&make_output.stderr)
         );
     }
 }

program/rust/src/accounts/permission.rs

@@ -11,8 +11,15 @@ use {
         Pod,
         Zeroable,
     },
-    solana_program::pubkey::Pubkey,
-    std::mem::size_of,
+    solana_program::{
+        account_info::AccountInfo,
+        program_error::ProgramError,
+        pubkey::Pubkey,
+    },
+    std::{
+        cell::RefMut,
+        mem::size_of,
+    },
 };
 
 /// This account stores the pubkeys that can execute administrative instructions in the Pyth
@@ -40,6 +47,9 @@ pub struct PermissionAccount {
 }
 
 impl PermissionAccount {
+    pub const MIN_SIZE_WITH_LAST_FEED_INDEX: usize =
+        size_of::<PermissionAccount>() + size_of::<u32>();
+
     pub fn is_authorized(&self, key: &Pubkey, command: OracleCommand) -> bool {
         #[allow(clippy::match_like_matches_macro)]
         match (*key, command) {
@@ -50,9 +60,25 @@ impl PermissionAccount {
             _ => false,
         }
     }
+
+    pub fn load_last_feed_index_mut<'a>(
+        account: &'a AccountInfo,
+    ) -> Result<RefMut<'a, u32>, ProgramError> {
+        let start = size_of::<PermissionAccount>();
+        let end = start + size_of::<u32>();
+        assert_eq!(Self::MIN_SIZE_WITH_LAST_FEED_INDEX, end);
+        if account.data_len() < end {
+            return Err(ProgramError::AccountDataTooSmall);
+        }
+        Ok(RefMut::map(account.try_borrow_mut_data()?, |data| {
+            bytemuck::from_bytes_mut(&mut data[start..end])
+        }))
+    }
 }
 
 impl PythAccount for PermissionAccount {
     const ACCOUNT_TYPE: u32 = PC_ACCTYPE_PERMISSIONS;
+    // TODO: change?
+    // TODO: add feed_index when creating account
     const INITIAL_SIZE: u32 = size_of::<PermissionAccount>() as u32;
 }

program/rust/src/accounts/price.rs

@@ -71,7 +71,7 @@ mod price_pythnet {
         pub flags:              PriceAccountFlags,
         /// Globally unique price feed index used for publishing.
         /// Limited to 28 bites.
-        pub feed_index:         i32,
+        pub feed_index:         u32,
         /// Corresponding product account
         pub product_account:    Pubkey,
         /// Next price account in the list

program/rust/src/error.rs

@@ -52,6 +52,8 @@ pub enum OracleError {
     PermissionViolation            = 619,
     #[error("NeedsSuccesfulAggregation")]
     NeedsSuccesfulAggregation      = 620,
+    #[error("MaxLastFeedIndexReached")]
+    MaxLastFeedIndexReached        = 621,
 }
 
 impl From<OracleError> for ProgramError {

program/rust/src/instruction.rs

@@ -103,6 +103,12 @@ pub enum OracleCommand {
     // account[0] funding account       [signer writable]
     // account[1] price account         [signer writable]
     SetMaxLatency         = 18,
+    /// Init price feed index
+    // account[0] funding account        [signer writable]
+    // account[1] price account          [writable]
+    // account[2] permissions account    [writable]
+    // account[3] system program account []
+    InitPriceFeedIndex    = 19,
 }
 
 #[repr(C)]

program/rust/src/lib.rs

@@ -1,4 +1,3 @@
-#![deny(warnings)]
 // Allow non upper case globals from C
 #![allow(non_upper_case_globals)]
 
@@ -29,6 +28,7 @@ mod log;
 // While we have `pyth-sdk-rs` which exposes a more friendly interface, this is still useful when a
 // downstream user wants to confirm for example that they can compile against the binary interface
 // of this program for their specific solana version.
+pub use crate::error::OracleError;
 #[cfg(feature = "strum")]
 pub use accounts::MessageType;
 #[cfg(feature = "library")]
@@ -47,7 +47,6 @@ pub use accounts::{
 };
 #[cfg(feature = "library")]
 pub use {
-    crate::error::OracleError,
     processor::find_publisher_index,
     utils::get_status_for_conf_price_ratio,
 };

program/rust/src/processor.rs

@@ -21,6 +21,7 @@ mod del_product;
 mod del_publisher;
 mod init_mapping;
 mod init_price;
+mod init_price_feed_index;
 mod set_max_latency;
 mod set_min_pub;
 mod upd_permissions;
@@ -32,6 +33,7 @@ pub use add_publisher::{
     DISABLE_ACCUMULATOR_V2,
     ENABLE_ACCUMULATOR_V2,
 };
+use init_price_feed_index::init_price_feed_index;
 pub use {
     add_price::add_price,
     add_product::add_product,
@@ -85,5 +87,6 @@ pub fn process_instruction(
         DelProduct => del_product(program_id, accounts, instruction_data),
         UpdPermissions => upd_permissions(program_id, accounts, instruction_data),
         SetMaxLatency => set_max_latency(program_id, accounts, instruction_data),
+        InitPriceFeedIndex => init_price_feed_index(program_id, accounts, instruction_data),
     }
 }

program/rust/src/processor/init_price_feed_index.rs

@@ -0,0 +1,100 @@
+use {
+    crate::{
+        accounts::{
+            PermissionAccount,
+            PriceAccount,
+        },
+        deserialize::{
+            load,
+            load_checked,
+        },
+        instruction::CommandHeader,
+        utils::{
+            check_permissioned_funding_account,
+            check_valid_funding_account,
+            pyth_assert,
+        },
+        OracleError,
+    },
+    solana_program::{
+        account_info::AccountInfo,
+        entrypoint::ProgramResult,
+        program::invoke,
+        program_error::ProgramError,
+        pubkey::Pubkey,
+        rent::Rent,
+        system_instruction,
+        sysvar::Sysvar,
+    },
+    std::mem::size_of,
+};
+
+/// Init price feed index
+// account[0] funding account       [signer writable]
+// account[1] price account         [writable]
+// account[2] permissions account   [writable]
+// account[3] system program account
+pub fn init_price_feed_index(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let cmd = load::<CommandHeader>(instruction_data)?;
+
+    pyth_assert(
+        instruction_data.len() == size_of::<CommandHeader>(),
+        ProgramError::InvalidArgument,
+    )?;
+
+    let (funding_account, price_account, permissions_account, system_program) = match accounts {
+        [x, y, p, z] => Ok((x, y, p, z)),
+        _ => Err(OracleError::InvalidNumberOfAccounts),
+    }?;
+
+    check_valid_funding_account(funding_account)?;
+    check_permissioned_funding_account(
+        program_id,
+        price_account,
+        funding_account,
+        permissions_account,
+        cmd,
+    )?;
+    pyth_assert(
+        solana_program::system_program::check_id(system_program.key),
+        OracleError::InvalidSystemAccount.into(),
+    )?;
+
+    if permissions_account.data_len() < PermissionAccount::MIN_SIZE_WITH_LAST_FEED_INDEX {
+        let new_size = PermissionAccount::MIN_SIZE_WITH_LAST_FEED_INDEX;
+        let rent = Rent::get()?;
+        let new_minimum_balance = rent.minimum_balance(new_size);
+        let lamports_diff = new_minimum_balance.saturating_sub(permissions_account.lamports());
+        if lamports_diff > 0 {
+            invoke(
+                &system_instruction::transfer(
+                    funding_account.key,
+                    permissions_account.key,
+                    lamports_diff,
+                ),
+                &[
+                    funding_account.clone(),
+                    permissions_account.clone(),
+                    system_program.clone(),
+                ],
+            )?;
+        }
+
+        permissions_account.realloc(new_size, true)?;
+    }
+    let mut last_feed_index = PermissionAccount::load_last_feed_index_mut(permissions_account)?;
+    *last_feed_index += 1;
+    pyth_assert(
+        *last_feed_index < (1 << 28),
+        OracleError::MaxLastFeedIndexReached.into(),
+    )?;
+
+    let mut price_account_data = load_checked::<PriceAccount>(price_account, cmd.version)?;
+    price_account_data.feed_index = *last_feed_index;
+
+    Ok(())
+}

program/rust/src/tests/test_upd_price_with_validator.rs

@@ -25,7 +25,10 @@ use {
             update_clock_slot,
             AccountSetup,
         },
-        validator,
+        validator::{
+            self,
+            checked_load_price_account_mut,
+        },
     },
     pythnet_sdk::messages::{
         PriceFeedMessage,
@@ -125,9 +128,13 @@ fn test_upd_price_with_validator() {
     }
 
     // We aggregate the price at the end of each slot now.
-    let messages1 =
-        validator::aggregate_price(1, 101, price_account.key, *price_account.data.borrow_mut())
-            .unwrap();
+    let messages1 = validator::aggregate_price(
+        1,
+        101,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     let expected_messages1 = [
         PriceFeedMessage {
             feed_id:           price_account.key.to_bytes(),
@@ -155,9 +162,13 @@ fn test_upd_price_with_validator() {
     assert_eq!(messages1, expected_messages1);
 
     update_clock_slot(&mut clock_account, 2);
-    let messages2 =
-        validator::aggregate_price(2, 102, price_account.key, *price_account.data.borrow_mut())
-            .unwrap();
+    let messages2 = validator::aggregate_price(
+        2,
+        102,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
 
     let expected_messages2 = [
         PriceFeedMessage {
@@ -214,8 +225,13 @@ fn test_upd_price_with_validator() {
 
     // next price doesn't change but slot does
     populate_instruction(&mut instruction_data, 81, 2, 3);
-    validator::aggregate_price(3, 103, price_account.key, *price_account.data.borrow_mut())
-        .unwrap();
+    validator::aggregate_price(
+        3,
+        103,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     update_clock_slot(&mut clock_account, 4);
     assert!(process_instruction(
         &program_id,
@@ -242,8 +258,13 @@ fn test_upd_price_with_validator() {
 
     // next price doesn't change and neither does aggregate but slot does
     populate_instruction(&mut instruction_data, 81, 2, 4);
-    validator::aggregate_price(4, 104, price_account.key, *price_account.data.borrow_mut())
-        .unwrap();
+    validator::aggregate_price(
+        4,
+        104,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     update_clock_slot(&mut clock_account, 5);
 
     assert!(process_instruction(
@@ -299,8 +320,13 @@ fn test_upd_price_with_validator() {
     }
 
     populate_instruction(&mut instruction_data, 50, 20, 5);
-    validator::aggregate_price(5, 105, price_account.key, *price_account.data.borrow_mut())
-        .unwrap();
+    validator::aggregate_price(
+        5,
+        105,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     update_clock_slot(&mut clock_account, 6);
 
     // Publishing a wide CI results in a status of unknown.
@@ -337,8 +363,13 @@ fn test_upd_price_with_validator() {
     // Crank one more time and aggregate should be unknown
     populate_instruction(&mut instruction_data, 50, 20, 6);
 
-    validator::aggregate_price(6, 106, price_account.key, *price_account.data.borrow_mut())
-        .unwrap();
+    validator::aggregate_price(
+        6,
+        106,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     update_clock_slot(&mut clock_account, 7);
 
 
@@ -367,8 +398,13 @@ fn test_upd_price_with_validator() {
 
     // Negative prices are accepted
     populate_instruction(&mut instruction_data, -100, 1, 7);
-    validator::aggregate_price(7, 107, price_account.key, *price_account.data.borrow_mut())
-        .unwrap();
+    validator::aggregate_price(
+        7,
+        107,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     update_clock_slot(&mut clock_account, 8);
 
 
@@ -397,8 +433,13 @@ fn test_upd_price_with_validator() {
 
     // Crank again for aggregate
     populate_instruction(&mut instruction_data, -100, 1, 8);
-    validator::aggregate_price(8, 108, price_account.key, *price_account.data.borrow_mut())
-        .unwrap();
+    validator::aggregate_price(
+        8,
+        108,
+        price_account.key,
+        checked_load_price_account_mut(*price_account.data.borrow_mut()).unwrap(),
+    )
+    .unwrap();
     update_clock_slot(&mut clock_account, 9);