[oracle] Bring back resize account (#360)

* checkpoint

* Remove all old sma files

* Bring back warnings denial

* Checkpoint

* Add some tests

* Cleanup

* Add test sizes

* Add another test

* Add another test

* Rename

* Finish test

* Delete weird files

* Delete resize_price_account

* Remove test gating

* Renames

* set initial size

* More tests

* Set initial size to the actual size for price accounts

* Checkpoint

* Update logic

* More changes

* Revert change

* Fix

* Format

* Fix test

* Write test

* Cleanup

* Fix comments

* Useless copy

* Comments

* Add size update

* Replace priceaccountsize by size_of

* CI

* Revert change

* Cleanup comment

* Comment

Author: guibescos

program/rust/src/accounts.rs

@@ -111,9 +111,10 @@ pub trait PythAccount: Pod {
             account.data_len() >= Self::MINIMUM_SIZE,
             OracleError::AccountTooSmall.into(),
         )?;
-
+        // Solana accounts are guaranteed to be zeroed when given to the program by an external creator.
+        // Since all already initialized accounts of the program have a non-zero header, an account with a zeroed header
+        // is guaranteed to be all 0s. Therefore we only need to check the header here.
         check_valid_fresh_account(account)?;
-
         {
             let mut account_header = load_account_as_mut::<AccountHeader>(account)?;
             account_header.magic_number = PC_MAGIC;

program/rust/src/accounts/permission.rs

@@ -44,7 +44,9 @@ impl PermissionAccount {
         #[allow(clippy::match_like_matches_macro)]
         match (*key, command) {
             (pubkey, _) if pubkey == self.master_authority => true,
-            (pubkey, OracleCommand::SetMinPub) if pubkey == self.security_authority => true,
+            (pubkey, OracleCommand::ResizePriceAccount) if pubkey == self.security_authority => {
+                true
+            } // Allow for an admin key to resize the price account
             _ => false,
         }
     }

program/rust/src/processor.rs

@@ -22,6 +22,7 @@ mod del_product;
 mod del_publisher;
 mod init_mapping;
 mod init_price;
+mod resize_price_account;
 mod set_min_pub;
 mod upd_permissions;
 mod upd_price;
@@ -37,6 +38,7 @@ pub use {
     del_publisher::del_publisher,
     init_mapping::init_mapping,
     init_price::init_price,
+    resize_price_account::resize_price_account,
     set_min_pub::set_min_pub,
     upd_permissions::upd_permissions,
     upd_price::{
@@ -71,7 +73,7 @@ pub fn process_instruction(
         UpdTest => Err(OracleError::UnrecognizedInstruction.into()),
         SetMinPub => set_min_pub(program_id, accounts, instruction_data),
         UpdPriceNoFailOnError => upd_price_no_fail_on_error(program_id, accounts, instruction_data),
-        ResizePriceAccount => Err(OracleError::UnrecognizedInstruction.into()),
+        ResizePriceAccount => resize_price_account(program_id, accounts, instruction_data),
         DelPrice => del_price(program_id, accounts, instruction_data),
         DelProduct => del_product(program_id, accounts, instruction_data),
         UpdPermissions => upd_permissions(program_id, accounts, instruction_data),

program/rust/src/processor/resize_price_account.rs

@@ -0,0 +1,95 @@
+use {
+    crate::{
+        accounts::{
+            PriceAccount,
+            PriceAccountV2,
+        },
+        c_oracle_header::PC_VERSION,
+        deserialize::{
+            load,
+            load_checked,
+        },
+        instruction::CommandHeader,
+        utils::{
+            check_valid_funding_account,
+            check_valid_signable_account_or_permissioned_funding_account,
+            get_rent,
+            pyth_assert,
+            send_lamports,
+            try_convert,
+        },
+        OracleError,
+    },
+    solana_program::{
+        account_info::AccountInfo,
+        entrypoint::ProgramResult,
+        pubkey::Pubkey,
+        rent::Rent,
+        system_program::check_id,
+    },
+    std::mem::size_of,
+};
+
+// Increase the size of an account allocated for a PriceAccount such that it can hold a PriceAccountV2
+// account[0] funding account       [signer writable]
+// account[1] price account         [signer writable]
+// account[2] system program        []
+pub fn resize_price_account(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let (funding_account, price_account, system_program, permissions_account_option) =
+        match accounts {
+            [x, y, z] => Ok((x, y, z, None)),
+            [x, y, z, p] => Ok((x, y, z, Some(p))),
+            _ => Err(OracleError::InvalidNumberOfAccounts),
+        }?;
+
+    let hdr = load::<CommandHeader>(instruction_data)?;
+
+    check_valid_funding_account(funding_account)?;
+    check_valid_signable_account_or_permissioned_funding_account(
+        program_id,
+        price_account,
+        funding_account,
+        permissions_account_option,
+        hdr,
+    )?;
+    pyth_assert(
+        check_id(system_program.key),
+        OracleError::InvalidSystemAccount.into(),
+    )?;
+
+    // Check that it is a valid initialized price account
+    {
+        load_checked::<PriceAccount>(price_account, PC_VERSION)?;
+    }
+    let account_len = price_account.try_data_len()?;
+    if account_len < size_of::<PriceAccountV2>() {
+        // Ensure account is still rent exempt after resizing
+        let rent: Rent = get_rent()?;
+        let lamports_needed: u64 = rent
+            .minimum_balance(size_of::<PriceAccountV2>())
+            .saturating_sub(price_account.lamports());
+        if lamports_needed > 0 {
+            send_lamports(
+                funding_account,
+                price_account,
+                system_program,
+                lamports_needed,
+            )?;
+        }
+        // We do not need to zero allocate because we won't access the data in the same
+        // instruction
+        price_account.realloc(size_of::<PriceAccountV2>(), false)?;
+
+        // Check that we can still load the account, update header size for homogeneity
+        {
+            let mut price_data = load_checked::<PriceAccount>(price_account, PC_VERSION)?;
+            price_data.header.size = try_convert(size_of::<PriceAccountV2>())?;
+        }
+    }
+
+    Ok(())
+}

program/rust/src/tests/mod.rs

@@ -15,6 +15,7 @@ mod test_message;
 mod test_permission_migration;
 mod test_publish;
 mod test_publish_batch;
+mod test_resize_price_account;
 mod test_set_min_pub;
 mod test_sizes;
 mod test_twap;

program/rust/src/tests/pyth_simulator.rs

@@ -505,16 +505,37 @@ impl PythSimulator {
     /// Setup 3 product accounts with 1 price account each and add a publisher to all of them.
     /// Returns the mapping of product symbol to price account pubkey.
     /// TODO : this fixture doesn't set the product metadata
-    pub async fn setup_product_fixture(&mut self, publisher: Pubkey) -> HashMap<String, Pubkey> {
+    pub async fn setup_product_fixture(
+        &mut self,
+        publisher: Pubkey,
+        security_authority: Pubkey,
+    ) -> HashMap<String, Pubkey> {
         let result_file =
             File::open("./test_data/publish/products.json").expect("Test file not found");
 
         self.airdrop(&publisher, 100 * LAMPORTS_PER_SOL)
             .await
             .unwrap();
 
+        self.airdrop(&security_authority, 100 * LAMPORTS_PER_SOL)
+            .await
+            .unwrap();
+
+        self.upd_permissions(
+            UpdPermissionsArgs {
+                header: OracleCommand::UpdPermissions.into(),
+                master_authority: self.upgrade_authority.pubkey(),
+                data_curation_authority: self.upgrade_authority.pubkey(),
+                security_authority,
+            },
+            &copy_keypair(&self.upgrade_authority),
+        )
+        .await
+        .unwrap();
+
         let product_metadatas: HashMap<String, ProductMetadata> =
             serde_json::from_reader(&result_file).unwrap();
+
         let mut price_accounts: HashMap<String, Pubkey> = HashMap::new();
         let mapping_keypair: Keypair = self.init_mapping().await.unwrap();
         for symbol in product_metadatas.keys() {
@@ -530,6 +551,29 @@ impl PythSimulator {
     pub async fn warp_to_slot(&mut self, slot: u64) -> Result<(), ProgramTestError> {
         self.context.warp_to_slot(slot)
     }
+
+    /// Resize a price account (using the resize_price_account
+    /// instruction).
+    pub async fn resize_price_account(
+        &mut self,
+        price_account: Pubkey,
+        security_authority: &Keypair,
+    ) -> Result<(), BanksClientError> {
+        let cmd: CommandHeader = OracleCommand::ResizePriceAccount.into();
+        let instruction = Instruction::new_with_bytes(
+            self.program_id,
+            bytes_of(&cmd),
+            vec![
+                AccountMeta::new(security_authority.pubkey(), true),
+                AccountMeta::new(price_account, false),
+                AccountMeta::new(system_program::id(), false),
+                AccountMeta::new_readonly(self.get_permissions_pubkey(), false),
+            ],
+        );
+
+        self.process_ixs(&[instruction], &vec![], security_authority)
+            .await
+    }
 }
 
 pub fn copy_keypair(keypair: &Keypair) -> Keypair {

program/rust/src/tests/test_permission_migration.rs

@@ -272,21 +272,23 @@ fn test_permission_migration() {
     );
 
 
-    // Security authority can change minimum number of publishers
-    process_instruction(
-        &program_id,
-        &[
-            security_auth_account.clone(),
-            price_account.clone(),
-            permissions_account.clone(),
-        ],
-        bytes_of::<SetMinPubArgs>(&SetMinPubArgs {
-            header:             SetMinPub.into(),
-            minimum_publishers: 5,
-            unused_:            [0; 3],
-        }),
-    )
-    .unwrap();
+    // Security authority can't change minimum number of publishers
+    assert_eq!(
+        process_instruction(
+            &program_id,
+            &[
+                security_auth_account.clone(),
+                price_account.clone(),
+                permissions_account.clone(),
+            ],
+            bytes_of::<SetMinPubArgs>(&SetMinPubArgs {
+                header:             SetMinPub.into(),
+                minimum_publishers: 5,
+                unused_:            [0; 3],
+            }),
+        ),
+        Err(OracleError::PermissionViolation.into())
+    );
 
     // Security authority can't add publishers
     assert_eq!(

program/rust/src/tests/test_publish.rs

@@ -1,6 +1,10 @@
 use {
     crate::{
-        accounts::PriceAccount,
+        accounts::{
+            PriceAccount,
+            PriceAccountV2,
+            PythAccount,
+        },
         c_oracle_header::{
             PC_STATUS_TRADING,
             PC_STATUS_UNKNOWN,
@@ -13,17 +17,22 @@ use {
     },
     solana_program::pubkey::Pubkey,
     solana_sdk::{
+        account::Account,
         signature::Keypair,
         signer::Signer,
     },
+    std::mem::size_of,
 };
 
 
 #[tokio::test]
 async fn test_publish() {
     let mut sim = PythSimulator::new().await;
     let publisher = Keypair::new();
-    let price_accounts = sim.setup_product_fixture(publisher.pubkey()).await;
+    let security_authority = Keypair::new();
+    let price_accounts = sim
+        .setup_product_fixture(publisher.pubkey(), security_authority.pubkey())
+        .await;
     let price = price_accounts["LTC"];
 
     // Check price account before publishing
@@ -106,6 +115,16 @@ async fn test_publish() {
         assert_eq!(price_data.comp_[0].agg_.status_, PC_STATUS_TRADING);
     }
 
+    // Resize, check if publishing still works
+    let price_account: Account = sim.get_account(price).await.unwrap();
+    assert_eq!(price_account.data.len(), PriceAccount::MINIMUM_SIZE);
+
+    sim.resize_price_account(price, &security_authority)
+        .await
+        .unwrap();
+    let price_account: Account = sim.get_account(price).await.unwrap();
+    assert_eq!(price_account.data.len(), size_of::<PriceAccountV2>());
+
     sim.warp_to_slot(3).await.unwrap();
     sim.upd_price(
         &publisher,

program/rust/src/tests/test_publish_batch.rs

@@ -24,7 +24,10 @@ use {
 async fn test_publish_batch() {
     let mut sim = PythSimulator::new().await;
     let publisher = Keypair::new();
-    let price_accounts = sim.setup_product_fixture(publisher.pubkey()).await;
+    let security_authority = Keypair::new();
+    let price_accounts = sim
+        .setup_product_fixture(publisher.pubkey(), security_authority.pubkey())
+        .await;
 
     for price in price_accounts.values() {
         let price_data = sim

program/rust/src/tests/test_resize_price_account.rs

@@ -0,0 +1,57 @@
+use {
+    crate::{
+        accounts::{
+            PriceAccount,
+            PriceAccountV2,
+        },
+        error::OracleError,
+        tests::pyth_simulator::PythSimulator,
+    },
+    solana_sdk::{
+        account::Account,
+        signature::Keypair,
+        signer::Signer,
+    },
+    std::mem::size_of,
+};
+
+#[tokio::test]
+async fn test_resize_price_account() {
+    let mut sim = PythSimulator::new().await;
+    let publisher = Keypair::new();
+    let security_authority = Keypair::new();
+    let price_accounts = sim
+        .setup_product_fixture(publisher.pubkey(), security_authority.pubkey())
+        .await;
+    let price = price_accounts["LTC"];
+
+    // Check size after initialization
+    let price_account = sim.get_account(price).await.unwrap();
+    assert_eq!(price_account.data.len(), size_of::<PriceAccount>());
+
+    // Run with the wrong authority
+    assert_eq!(
+        sim.resize_price_account(price, &publisher)
+            .await
+            .unwrap_err()
+            .unwrap(),
+        OracleError::PermissionViolation.into()
+    );
+
+    // Run the instruction once
+    assert!(sim
+        .resize_price_account(price, &security_authority)
+        .await
+        .is_ok());
+    // Check new size
+    let price_account: Account = sim.get_account(price).await.unwrap();
+    assert_eq!(price_account.data.len(), size_of::<PriceAccountV2>());
+
+    // Future calls don't change the size
+    assert!(sim
+        .resize_price_account(price, &security_authority)
+        .await
+        .is_ok());
+    let price_account = sim.get_account(price).await.unwrap();
+    assert_eq!(price_account.data.len(), size_of::<PriceAccountV2>());
+}