feat(oracle)!: backport ResizeMapping ix from v2.35 to v2.32.1 for pythtest-conformance

program/c/src/oracle/oracle.h

@@ -20,7 +20,7 @@ extern "C" {
 // various size constants
 #define PC_PUBKEY_SIZE       32
 #define PC_PUBKEY_SIZE_64   (PC_PUBKEY_SIZE/sizeof(uint64_t))
-#define PC_MAP_TABLE_SIZE   640
+#define PC_MAP_TABLE_SIZE   5000
 
   // Total price component slots available
 #define PC_NUM_COMP_PYTHNET     128
@@ -117,7 +117,7 @@ typedef struct pc_map_table
   pc_pub_key_t    prod_[PC_MAP_TABLE_SIZE]; // product accounts
 } pc_map_table_t;
 
-static_assert( sizeof( pc_map_table_t ) == 20536, "" );
+static_assert( sizeof( pc_map_table_t ) == 160056, "" );
 
 // variable length string
 typedef struct pc_str

program/rust/src/error.rs

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

program/rust/src/instruction.rs

@@ -103,6 +103,9 @@ pub enum OracleCommand {
     // account[0] funding account       [signer writable]
     // account[1] price account         [signer writable]
     SetMaxLatency         = 18,
+
+    // account[0] mapping account [writable]
+    ResizeMapping         = 20,
 }
 
 #[repr(C)]

program/rust/src/processor.rs

@@ -21,6 +21,7 @@ mod del_product;
 mod del_publisher;
 mod init_mapping;
 mod init_price;
+mod resize_mapping;
 mod set_max_latency;
 mod set_min_pub;
 mod upd_permissions;
@@ -41,6 +42,7 @@ pub use {
     del_publisher::del_publisher,
     init_mapping::init_mapping,
     init_price::init_price,
+    resize_mapping::resize_mapping,
     set_max_latency::set_max_latency,
     set_min_pub::set_min_pub,
     upd_permissions::upd_permissions,
@@ -84,5 +86,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),
+        ResizeMapping => resize_mapping(program_id, accounts, instruction_data),
     }
 }

program/rust/src/processor/resize_mapping.rs

@@ -0,0 +1,71 @@
+use {
+    crate::{
+        accounts::{
+            AccountHeader,
+            MappingAccount,
+            PythAccount,
+        },
+        c_oracle_header::PC_MAGIC,
+        deserialize::{
+            load,
+            load_account_as,
+        },
+        instruction::CommandHeader,
+        utils::{
+            check_valid_writable_account,
+            pyth_assert,
+        },
+        OracleError,
+    },
+    solana_program::{
+        account_info::AccountInfo,
+        entrypoint::{
+            ProgramResult,
+            MAX_PERMITTED_DATA_INCREASE,
+        },
+        pubkey::Pubkey,
+    },
+    std::{
+        cmp::min,
+        mem::size_of,
+    },
+};
+
+/// Resize mapping account.
+// account[0] mapping account [writable]
+pub fn resize_mapping(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let mapping_account = match accounts {
+        [x] => Ok(x),
+        _ => Err(OracleError::InvalidNumberOfAccounts),
+    }?;
+
+    let hdr = load::<CommandHeader>(instruction_data)?;
+
+    check_valid_writable_account(program_id, mapping_account)?;
+
+    {
+        let account_header = load_account_as::<AccountHeader>(mapping_account)?;
+        pyth_assert(
+            account_header.magic_number == PC_MAGIC
+                && account_header.version == hdr.version
+                && account_header.account_type == MappingAccount::ACCOUNT_TYPE,
+            OracleError::InvalidAccountHeader.into(),
+        )?;
+    }
+
+    pyth_assert(
+        mapping_account.data_len() < size_of::<MappingAccount>(),
+        OracleError::NoNeedToResize.into(),
+    )?;
+    let new_size = min(
+        size_of::<MappingAccount>(),
+        mapping_account.data_len() + MAX_PERMITTED_DATA_INCREASE,
+    );
+    mapping_account.realloc(new_size, true)?;
+
+    Ok(())
+}

program/rust/src/tests/mod.rs

@@ -17,6 +17,7 @@ mod test_message;
 mod test_permission_migration;
 mod test_publish;
 mod test_publish_batch;
+mod test_resize_mapping;
 mod test_set_max_latency;
 mod test_set_min_pub;
 mod test_sizes;

program/rust/src/tests/pyth_simulator.rs

@@ -478,6 +478,31 @@ impl PythSimulator {
             .map(|_| permissions_pubkey)
     }
 
+    pub async fn truncate_account(&mut self, key: Pubkey, size: usize) {
+        let mut account = self.get_account(key).await.unwrap();
+        account.data.truncate(size);
+        self.context.set_account(&key, &account.into());
+    }
+
+    pub async fn resize_mapping(
+        &mut self,
+        mapping_keypair: &Keypair,
+    ) -> Result<(), BanksClientError> {
+        let cmd: CommandHeader = OracleCommand::ResizeMapping.into();
+        let instruction = Instruction::new_with_bytes(
+            self.program_id,
+            bytes_of(&cmd),
+            vec![AccountMeta::new(mapping_keypair.pubkey(), false)],
+        );
+
+        self.process_ixs(
+            &[instruction],
+            &vec![],
+            &copy_keypair(&self.genesis_keypair),
+        )
+        .await
+    }
+
     /// Get the account at `key`. Returns `None` if no such account exists.
     pub async fn get_account(&mut self, key: Pubkey) -> Option<Account> {
         self.context.banks_client.get_account(key).await.unwrap()

program/rust/src/tests/test_del_product.rs

@@ -1,6 +1,7 @@
 use {
     crate::{
         accounts::MappingAccount,
+        deserialize::load,
         tests::pyth_simulator::PythSimulator,
     },
     solana_program::pubkey::Pubkey,
@@ -41,32 +42,31 @@ async fn test_del_product() {
 
     assert!(sim.get_account(product2.pubkey()).await.is_none());
 
-    let mapping_data = sim
-        .get_account_data_as::<MappingAccount>(mapping_keypair.pubkey())
-        .await
-        .unwrap();
-    assert!(mapping_product_list_equals(
-        &mapping_data,
-        vec![
-            product1.pubkey(),
-            product5.pubkey(),
-            product3.pubkey(),
-            product4.pubkey()
-        ]
-    ));
+    {
+        let mapping_account = sim.get_account(mapping_keypair.pubkey()).await.unwrap();
+        let mapping_data = load::<MappingAccount>(&mapping_account.data).unwrap();
+        assert!(mapping_product_list_equals(
+            mapping_data,
+            vec![
+                product1.pubkey(),
+                product5.pubkey(),
+                product3.pubkey(),
+                product4.pubkey()
+            ]
+        ));
+    }
     assert!(sim.get_account(product5.pubkey()).await.is_some());
 
 
     assert!(sim.del_product(&mapping_keypair, &product4).await.is_ok());
-    let mapping_data = sim
-        .get_account_data_as::<MappingAccount>(mapping_keypair.pubkey())
-        .await
-        .unwrap();
-
-    assert!(mapping_product_list_equals(
-        &mapping_data,
-        vec![product1.pubkey(), product5.pubkey(), product3.pubkey()]
-    ));
+    {
+        let mapping_account = sim.get_account(mapping_keypair.pubkey()).await.unwrap();
+        let mapping_data = load::<MappingAccount>(&mapping_account.data).unwrap();
+        assert!(mapping_product_list_equals(
+            mapping_data,
+            vec![product1.pubkey(), product5.pubkey(), product3.pubkey()]
+        ));
+    }
 }
 
 /// Returns true if the list of products in `mapping_data` contains the keys in `expected` (in the

program/rust/src/tests/test_resize_mapping.rs

@@ -0,0 +1,54 @@
+use {
+    super::pyth_simulator::PythSimulator,
+    crate::{
+        accounts::MappingAccount,
+        error::OracleError,
+    },
+    solana_sdk::{
+        instruction::InstructionError,
+        signer::Signer,
+        transaction::TransactionError,
+    },
+    std::mem::size_of,
+};
+
+
+#[tokio::test]
+async fn test_resize_mapping() {
+    let mut sim = PythSimulator::new().await;
+    let mapping_keypair = sim.init_mapping().await.unwrap();
+    assert_eq!(
+        sim.resize_mapping(&mapping_keypair)
+            .await
+            .unwrap_err()
+            .unwrap(),
+        TransactionError::InstructionError(
+            0,
+            InstructionError::Custom(OracleError::NoNeedToResize as u32)
+        )
+    );
+
+    sim.truncate_account(mapping_keypair.pubkey(), 20536).await; // Old size.
+    for i in 0..14 {
+        println!("resize #{i}");
+        sim.resize_mapping(&mapping_keypair).await.unwrap();
+    }
+    assert_eq!(
+        sim.resize_mapping(&mapping_keypair)
+            .await
+            .unwrap_err()
+            .unwrap(),
+        TransactionError::InstructionError(
+            0,
+            InstructionError::Custom(OracleError::NoNeedToResize as u32)
+        )
+    );
+    assert_eq!(
+        sim.get_account(mapping_keypair.pubkey())
+            .await
+            .unwrap()
+            .data
+            .len(),
+        size_of::<MappingAccount>()
+    );
+}

program/rust/src/tests/test_sizes.rs

@@ -86,7 +86,7 @@ fn test_sizes() {
     assert_eq!(size_of::<UpdPriceArgs>(), 40);
     assert_eq!(size_of::<Pubkey>(), 32);
     assert_eq!(size_of::<AccountHeader>(), 16);
-    assert_eq!(size_of::<MappingAccount>(), 20536);
+    assert_eq!(size_of::<MappingAccount>(), 160056);
     assert_eq!(size_of::<ProductAccount>(), 48);
     assert_eq!(size_of::<PriceComponent>(), 96);
     assert_eq!(size_of::<PriceEma>(), 24);

program/rust/src/tests/test_utils.rs

@@ -34,7 +34,7 @@ use {
     solana_sdk::transaction::TransactionError,
 };
 
-const UPPER_BOUND_OF_ALL_ACCOUNT_SIZES: usize = 20536;
+const UPPER_BOUND_OF_ALL_ACCOUNT_SIZES: usize = 160056;
 
 /// The goal of this struct is to easily instantiate fresh solana accounts
 /// for the Pyth program to use in tests.
@@ -50,7 +50,7 @@ pub struct AccountSetup {
     owner:   Pubkey,
     balance: u64,
     size:    usize,
-    data:    [u8; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES],
+    data:    Vec<u8>,
 }
 
 impl AccountSetup {
@@ -59,7 +59,7 @@ impl AccountSetup {
         let owner = *owner;
         let balance = Rent::minimum_balance(&Rent::default(), T::MINIMUM_SIZE);
         let size = T::MINIMUM_SIZE;
-        let data = [0; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
+        let data = vec![0; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
         AccountSetup {
             key,
             owner,
@@ -74,7 +74,7 @@ impl AccountSetup {
         let owner = system_program::id();
         let balance = LAMPORTS_PER_SOL;
         let size = 0;
-        let data = [0; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
+        let data = vec![0; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
         AccountSetup {
             key,
             owner,
@@ -89,7 +89,7 @@ impl AccountSetup {
         let owner = *owner;
         let balance = Rent::minimum_balance(&Rent::default(), PermissionAccount::MINIMUM_SIZE);
         let size = PermissionAccount::MINIMUM_SIZE;
-        let data = [0; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
+        let data = vec![0; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
         AccountSetup {
             key,
             owner,
@@ -104,7 +104,7 @@ impl AccountSetup {
         let owner = sysvar::id();
         let balance = Rent::minimum_balance(&Rent::default(), clock::Clock::size_of());
         let size = clock::Clock::size_of();
-        let data = [0u8; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
+        let data = vec![0u8; UPPER_BOUND_OF_ALL_ACCOUNT_SIZES];
         AccountSetup {
             key,
             owner,