feat: accumulator v2 (wip 1)

Author: Riateche

runtime/src/bank.rs

@@ -199,6 +199,8 @@ mod builtin_programs;
 mod sysvar_cache;
 mod transaction_account_state_info;
 
+mod pyth_accumulator;
+
 pub const SECONDS_PER_YEAR: f64 = 365.25 * 24.0 * 60.0 * 60.0;
 
 pub const MAX_LEADER_SCHEDULE_STAKES: Epoch = 5;
@@ -2242,9 +2244,31 @@ impl Bank {
         }
 
         info!("Accumulator: Updating accumulator. Slot: {}", self.slot());
-        if let Err(e) = self.update_accumulator_impl() {
-            error!("Error updating accumulator: {:?}", e);
+
+        lazy_static! {
+            static ref ACCUMULATOR_V2_SLOT: Option<Slot> =
+                match std::env::var("PYTH_ACCUMULATOR_V2_FROM_SLOT") {
+                    Ok(value) => Some(
+                        value
+                            .parse()
+                            .expect("invalid value of PYTH_ACCUMULATOR_V2_FROM_SLOT env var")
+                    ),
+                    Err(std::env::VarError::NotPresent) => None,
+                    Err(std::env::VarError::NotUnicode(err)) => {
+                        panic!("invalid value of PYTH_ACCUMULATOR_V2_FROM_SLOT env var: {err:?}");
+                    }
+                };
         }
+
+        if ACCUMULATOR_V2_SLOT.map_or(false, |v2_slot| self.slot >= v2_slot) {
+            if let Err(e) = pyth_accumulator::update_v2(&self) {
+                error!("Error updating accumulator: {:?}", e);
+            }
+        } else {
+            if let Err(e) = self.update_accumulator_impl() {
+                error!("Error updating accumulator: {:?}", e);
+            }
+        };
     }
 
     fn update_accumulator_impl(&self) -> std::result::Result<(), AccumulatorUpdateError> {

runtime/src/bank/pyth_accumulator.rs

@@ -0,0 +1,42 @@
+use std::env::{self, VarError};
+
+use solana_sdk::pubkey::Pubkey;
+
+use crate::accounts_index::{ScanConfig, ScanError};
+
+use super::Bank;
+
+#[derive(Debug, thiserror::Error)]
+pub enum AccumulatorUpdateV2Error {
+    #[error("no oracle pubkey")]
+    NoOraclePubkey,
+    #[error("get_program_accounts failed to return accounts: {0}")]
+    GetProgramAccounts(#[from] ScanError),
+}
+
+lazy_static! {
+    static ref ORACLE_PUBKEY: Option<Pubkey> = match env::var("PYTH_ORACLE_PUBKEY") {
+        Ok(value) => Some(
+            value
+                .parse()
+                .expect("invalid value of PYTH_ORACLE_PUBKEY env var")
+        ),
+        Err(VarError::NotPresent) => None,
+        Err(VarError::NotUnicode(err)) => {
+            panic!("invalid value of PYTH_ORACLE_PUBKEY env var: {err:?}");
+        }
+    };
+}
+
+pub fn update_v2(bank: &Bank) -> std::result::Result<(), AccumulatorUpdateV2Error> {
+    let Some(oracle_pubkey) = &*ORACLE_PUBKEY else {
+        return Err(AccumulatorUpdateV2Error::NoOraclePubkey);
+    };
+
+    let accounts = bank
+        .get_program_accounts(oracle_pubkey, &ScanConfig::new(true))
+        .map_err(AccumulatorUpdateV2Error::GetProgramAccounts)?;
+
+    //...
+    Ok(())
+}

sdk/program/src/account_info.rs

@@ -184,6 +184,7 @@ impl<'a> AccountInfo<'a> {
     pub fn assign(&self, new_owner: &Pubkey) {
         // Set the non-mut owner field
         unsafe {
+            #[allow(invalid_reference_casting)]
             std::ptr::write_volatile(
                 self.owner as *const Pubkey as *mut [u8; 32],
                 new_owner.to_bytes(),