Add slot check in load_price for bpf arch (on-chain programs)

- Introduces another Price struct which doesn't have comps (published prices) and unused fields. The reason is that we want to mutate struct (to add the check) and Price Account Data has ~3kb so copying is expensive. This creates a significantly smaller one. This naming allow us to have least impact on existing consumers. The price account data is available as price account data if a consumer needs it.
- Also make Ema fields public

Author: ali-behjati

src/instruction.rs

@@ -34,6 +34,10 @@ pub enum PythClientInstruction {
   ///
   /// No accounts required for this instruction
   Noop,
+
+  PriceNotStale {
+    price_account_data: Vec<u8>
+  }
 }
 
 pub fn divide(numerator: PriceConf, denominator: PriceConf) -> Instruction {
@@ -94,3 +98,14 @@ pub fn noop() -> Instruction {
     data: PythClientInstruction::Noop.try_to_vec().unwrap(),
   }
 }
+
+// Returns ok if price is not stale
+pub fn price_not_stale(price_account_data: Vec<u8>) -> Instruction {
+  Instruction {
+    program_id: id(), 
+    accounts: vec![],
+    data: PythClientInstruction::PriceNotStale { price_account_data }
+      .try_to_vec()
+      .unwrap(),
+  }
+}

src/lib.rs

@@ -18,15 +18,19 @@ use bytemuck::{
   Pod, PodCastError, Zeroable,
 };
 
+#[cfg(target_arch = "bpf")]
+use solana_program::{clock::Clock, sysvar::Sysvar};
+
 solana_program::declare_id!("PythC11111111111111111111111111111111111111");
 
-pub const MAGIC          : u32   = 0xa1b2c3d4;
-pub const VERSION_2      : u32   = 2;
-pub const VERSION        : u32   = VERSION_2;
-pub const MAP_TABLE_SIZE : usize = 640;
-pub const PROD_ACCT_SIZE : usize = 512;
-pub const PROD_HDR_SIZE  : usize = 48;
-pub const PROD_ATTR_SIZE : usize = PROD_ACCT_SIZE - PROD_HDR_SIZE;
+pub const MAGIC            : u32   = 0xa1b2c3d4;
+pub const VERSION_2        : u32   = 2;
+pub const VERSION          : u32   = VERSION_2;
+pub const MAP_TABLE_SIZE   : usize = 640;
+pub const PROD_ACCT_SIZE   : usize = 512;
+pub const PROD_HDR_SIZE    : usize = 48;
+pub const PROD_ATTR_SIZE   : usize = PROD_ACCT_SIZE - PROD_HDR_SIZE;
+pub const MAX_SEND_LATENCY : u64   = 25; 
 
 /// The type of Pyth account determines what data it contains
 #[derive(Copy, Clone)]
@@ -180,15 +184,15 @@ pub struct Ema
   /// The current value of the EMA
   pub val        : i64,
   /// numerator state for next update
-  numer          : i64,
+  pub numer          : i64,
   /// denominator state for next update
-  denom          : i64
+  pub denom          : i64
 }
 
 /// Price accounts represent a continuously-updating price feed for a product.
 #[derive(Copy, Clone)]
 #[repr(C)]
-pub struct Price
+pub struct PriceAccountData
 {
   /// pyth magic number
   pub magic      : u32,
@@ -235,14 +239,71 @@ pub struct Price
   /// price components one per quoter
   pub comp       : [PriceComp;32]
 }
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct Price {
+    /// account type
+    pub atype      : u32,
+    /// price account size
+    pub size       : u32,
+    /// price or calculation type
+    pub ptype      : PriceType,
+    /// price exponent
+    pub expo       : i32,
+    /// number of component prices
+    pub num        : u32,
+    /// number of quoters that make up aggregate
+    pub num_qt     : u32,
+    /// slot of last valid (not unknown) aggregate price
+    pub last_slot  : u64,
+    /// valid slot-time of agg. price
+    pub valid_slot : u64,
+    /// time-weighted average price
+    pub twap       : Ema,
+    /// time-weighted average confidence interval
+    pub twac       : Ema,
+    /// product account key
+    pub prod       : AccKey,
+    /// next Price account in linked list
+    pub next       : AccKey,
+    /// valid slot of previous update
+    pub prev_slot  : u64,
+    /// aggregate price of previous update
+    pub prev_price : i64,
+    /// confidence interval of previous update
+    pub prev_conf  : u64,
+    /// aggregate price info
+    pub agg        : PriceInfo,
+}
 
 #[cfg(target_endian = "little")]
-unsafe impl Zeroable for Price {}
+unsafe impl Zeroable for PriceAccountData {}
 
 #[cfg(target_endian = "little")]
-unsafe impl Pod for Price {}
+unsafe impl Pod for PriceAccountData {}
 
 impl Price {
+  fn from_price_account_data(price_account_data: &PriceAccountData) -> Self {
+    Price {
+      atype: price_account_data.atype,
+      size: price_account_data.size,
+      ptype: price_account_data.ptype,
+      expo: price_account_data.expo,
+      num: price_account_data.num,
+      num_qt: price_account_data.num_qt,
+      last_slot: price_account_data.last_slot,
+      valid_slot: price_account_data.valid_slot,
+      twap: price_account_data.twap,
+      twac: price_account_data.twac,
+      prod: price_account_data.prod,
+      next: price_account_data.next,
+      prev_slot: price_account_data.prev_slot,
+      prev_price: price_account_data.prev_price,
+      prev_conf: price_account_data.prev_conf,
+      agg: price_account_data.agg
+    }
+  }
+
   /**
    * Get the current price and confidence interval as fixed-point numbers of the form a * 10^e.
    * Returns a struct containing the current price, confidence interval, and the exponent for both
@@ -378,19 +439,38 @@ pub fn load_product(data: &[u8]) -> Result<&Product, PythError> {
 }
 
 /** Get a `Price` account from the raw byte value of a Solana account. */
-pub fn load_price(data: &[u8]) -> Result<&Price, PythError> {
-  let pyth_price = load::<Price>(&data).map_err(|_| PythError::InvalidAccountData)?;
+pub fn load_price_account_data(data: &[u8]) -> Result<&PriceAccountData, PythError> {
+  let price_account_data = load::<PriceAccountData>(&data).map_err(|_| PythError::InvalidAccountData)?;
 
-  if pyth_price.magic != MAGIC {
+  if price_account_data.magic != MAGIC {
     return Err(PythError::InvalidAccountData);
   }
-  if pyth_price.ver != VERSION_2 {
+  if price_account_data.ver != VERSION_2 {
     return Err(PythError::BadVersionNumber);
   }
-  if pyth_price.atype != AccountType::Price as u32 {
+  if price_account_data.atype != AccountType::Price as u32 {
     return Err(PythError::WrongAccountType);
   }
 
+  return Ok(price_account_data);
+}
+
+/** Get a modified `Price` struct from the raw byte value of a Solana Price account.
+ *  If used on-chain it will update the status to unknown if price is not updated for a long time.
+*/
+pub fn load_price(data: &[u8]) -> Result<Price, PythError> {
+  let price_account_data = load_price_account_data(data)?;
+
+  #[allow(unused_mut)]
+  let mut pyth_price = Price::from_price_account_data(price_account_data);
+
+  #[cfg(target_arch = "bpf")]
+  if let PriceStatus::Trading = pyth_price.agg.status {
+    if Clock::get().unwrap().slot - pyth_price.agg.pub_slot > MAX_SEND_LATENCY {
+      pyth_price.agg.status = PriceStatus::Unknown;
+    }
+  }
+
   return Ok(pyth_price);
 }
 

src/processor.rs

@@ -5,10 +5,11 @@ use solana_program::{
   account_info::AccountInfo,
   entrypoint::ProgramResult,
   pubkey::Pubkey,
+  program_error::ProgramError
 };
 
 use crate::{
-  instruction::PythClientInstruction,
+  instruction::PythClientInstruction, load_price, PriceStatus,
 };
 
 pub fn process_instruction(
@@ -41,5 +42,15 @@ pub fn process_instruction(
     PythClientInstruction::Noop => {
       Ok(())
     }
+    PythClientInstruction::PriceNotStale { price_account_data } => {
+      let price = load_price(&price_account_data[..])?;
+      
+      match price.agg.status {
+        PriceStatus::Trading => {
+          Ok(())
+        }
+        _ => Err(ProgramError::Custom(0))
+      }
+    }
   }
 }

tests/stale_price.rs

@@ -0,0 +1,94 @@
+#![cfg(feature = "test-bpf")] // This only runs on bpf
+
+use {
+    bytemuck::bytes_of,
+    pyth_client::{id, MAGIC, VERSION_2, instruction, PriceType, PriceAccountData, AccountType, AccKey, Ema, PriceComp, PriceInfo, CorpAction, PriceStatus},
+    pyth_client::processor::process_instruction,
+    solana_program::instruction::Instruction,
+    solana_program_test::*,
+    solana_sdk::{signature::Signer, transaction::Transaction, transport::TransportError},
+};
+
+async fn test_instr(instr: Instruction) -> Result<(), TransportError> {
+    let (mut banks_client, payer, recent_blockhash) = ProgramTest::new(
+        "pyth_client",
+        id(),
+        processor!(process_instruction),
+    )
+        .start()
+        .await;
+    let mut transaction = Transaction::new_with_payer(
+        &[instr],
+        Some(&payer.pubkey()),
+    );
+    transaction.sign(&[&payer], recent_blockhash);
+    banks_client.process_transaction(transaction).await
+}
+
+fn price_all_zero() -> PriceAccountData {
+    let acc_key = AccKey {
+        val: [0; 32]
+    };
+
+    let ema = Ema {
+        val: 0,
+        numer: 0,
+        denom: 0
+    };
+
+    let price_info = PriceInfo {
+        conf: 0,
+        corp_act: CorpAction::NoCorpAct,
+        price: 0,
+        pub_slot: 0,
+        status: PriceStatus::Unknown
+    };
+
+    let price_comp = PriceComp {
+        agg: price_info,
+        latest: price_info,
+        publisher: acc_key
+    };
+
+    PriceAccountData {
+        magic: MAGIC,
+        ver: VERSION_2,
+        atype: AccountType::Price as u32,
+        size: 0,
+        ptype: PriceType::Price,
+        expo: 0,
+        num: 0,
+        num_qt: 0,
+        last_slot: 0,
+        valid_slot: 0,
+        twap: ema,
+        twac: ema,
+        drv1: 0,
+        drv2: 0,
+        prod: acc_key,
+        next: acc_key,
+        prev_slot: 0,
+        prev_price: 0,
+        prev_conf: 0,
+        drv3: 0,
+        agg: price_info,
+        comp: [price_comp; 32]
+    }
+}
+
+
+#[tokio::test]
+async fn test_price_not_stale() {
+    let mut price = price_all_zero();
+    price.agg.status = PriceStatus::Trading;
+    test_instr(instruction::price_not_stale(bytes_of(&price).to_vec())).await.unwrap();
+}
+
+
+#[tokio::test]
+async fn test_price_stale() {
+    let mut price = price_all_zero();
+    price.agg.status = PriceStatus::Trading;
+    price.agg.pub_slot = 100; // It will cause an overflow because this is bigger than Solana slot which is impossible in reality
+    test_instr(instruction::price_not_stale(bytes_of(&price).to_vec())).await.unwrap_err();
+}