fix: ix bugs on pyth lazer oracle crank

Author: LukasDeco

programs/drift/src/instructions/pyth_lazer_oracle.rs

@@ -7,7 +7,9 @@ use crate::state::pyth_lazer_oracle::{
 use crate::validate;
 use anchor_lang::prelude::*;
 use pyth_lazer_solana_contract::protocol::message::SolanaMessage;
-use pyth_lazer_solana_contract::protocol::payload::{PayloadData, PayloadPropertyValue};
+use pyth_lazer_solana_contract::protocol::payload::{
+    PayloadData, PayloadPropertyValue, TimestampUs,
+};
 use pyth_lazer_solana_contract::protocol::router::Price;
 use pyth_lazer_solana_contract::Storage;
 use solana_program::sysvar::instructions::load_current_index_checked;
@@ -76,23 +78,26 @@ pub fn handle_update_pyth_lazer_oracle<'c: 'info, 'info>(
         let mut best_bid_price: Option<Price> = None;
         let mut best_ask_price: Option<Price> = None;
         let mut exponent: Option<i16> = None;
-        let mut feed_update_timestamp: Option<TimestampUs> = None;
+        let mut feed_update_timestamp: Option<u64> = None;
 
         for property in &payload_data.properties {
             match property {
                 PayloadPropertyValue::BestBidPrice(price) => best_bid_price = *price,
                 PayloadPropertyValue::BestAskPrice(price) => best_ask_price = *price,
                 PayloadPropertyValue::Exponent(exp) => exponent = Some(*exp),
-                PayloadPropertyValue::FeedUpdateTimestamp(timestamp) => {
-                    feed_update_timestamp = *timestamp
-                }
+                PayloadPropertyValue::FeedUpdateTimestamp(timestamp) => match timestamp {
+                    Some(timestamp) => match *timestamp {
+                        TimestampUs(ts) => feed_update_timestamp = Some(ts),
+                    },
+                    None => return Err(ErrorCode::InvalidPythLazerMessage.into()),
+                },
                 _ => {}
             }
         }
 
         match feed_update_timestamp {
             Some(timestamp) => {
-                if timestamp > current_timestamp {
+                if current_timestamp >= timestamp {
                     msg!(
                         "Skipping lazer price update. current ts {} >= feed_update_timestamp {}",
                         current_timestamp,
@@ -102,6 +107,7 @@ pub fn handle_update_pyth_lazer_oracle<'c: 'info, 'info>(
                 }
             }
             None => {
+                msg!("Skipping lazer price update. feed_update_timestamp is None",);
                 return Err(ErrorCode::InvalidPythLazerMessage.into());
             }
         }
@@ -124,15 +130,15 @@ pub fn handle_update_pyth_lazer_oracle<'c: 'info, 'info>(
 
         pyth_lazer_oracle.price = price;
         pyth_lazer_oracle.posted_slot = Clock::get()?.slot;
-        pyth_lazer_oracle.publish_time = feed_update_timestamp;
+        pyth_lazer_oracle.publish_time = feed_update_timestamp.unwrap();
         pyth_lazer_oracle.exponent = exponent.cast::<i32>()?;
         pyth_lazer_oracle.conf = conf.cast::<u64>()?;
         msg!("Price updated to {}", price);
 
         msg!(
             "Posting new lazer update. current ts {} < feed_update_timestamp {}",
             current_timestamp,
-            feed_update_timestamp
+            feed_update_timestamp.unwrap()
         );
     }
 

sdk/src/pyth/pythLazerSubscriber.ts

@@ -28,6 +28,9 @@ export class PythLazerSubscriber {
 	private pythLazerClient?: PythLazerClient;
 	feedIdChunkToPriceMessage: Map<string, string> = new Map();
 	feedIdToPrice: Map<number, number> = new Map();
+	/** Map of feed IDs to whether the price is stale
+	 * Not used right now. Want to implement this so we know we can use staleness checks on the client if we want to in the future.
+	 */
 	feedIdToIsStale: Map<number, boolean> = new Map();
 	feedIdHashToFeedIds: Map<string, number[]> = new Map();
 	subscriptionIdsToFeedIdsHash: Map<number, string> = new Map();
@@ -359,48 +362,4 @@ export class PythLazerSubscriber {
 		}
 		return this.feedIdToPrice.get(feedId);
 	}
-
-	/**
-	 * Returns whether the current price for a feed ID is stale (carried forward from an earlier update).
-	 * Use feedUpdateTimestamp vs timestampUs: if feedUpdateTimestamp < timestampUs, the price is stale.
-	 * @param feedId - The Pyth Lazer feed ID to check
-	 * @returns true if price is carried forward (e.g. market closed, no new data), false if fresh, undefined if no data
-	 */
-	isFeedIdStale(feedId: number): boolean | undefined {
-		return this.feedIdToIsStale.get(feedId);
-	}
-
-	/**
-	 * Returns whether the current price for a market is stale (carried forward from an earlier update).
-	 * Use feedUpdateTimestamp vs timestampUs: if feedUpdateTimestamp < timestampUs, the price is stale.
-	 * @param marketIndex - The market index to check
-	 * @returns true if price is carried forward (e.g. market closed, no new data), false if fresh, undefined if no data
-	 */
-	isPriceStaleForMarket(marketIndex: number): boolean | undefined {
-		const feedId = this.marketIndextoPriceFeedId.get(marketIndex);
-		if (feedId === undefined) {
-			return undefined;
-		}
-		return this.feedIdToIsStale.get(feedId);
-	}
-
-	/**
-	 * Gets the current price and staleness for a market index.
-	 * @param marketIndex - The market index to get the price for
-	 * @returns Object with price and isStale, or undefined if no price available
-	 */
-	getPriceWithStaleness(
-		marketIndex: number
-	): { price: number; isStale: boolean } | undefined {
-		const feedId = this.marketIndextoPriceFeedId.get(marketIndex);
-		if (feedId === undefined) {
-			return undefined;
-		}
-		const price = this.feedIdToPrice.get(feedId);
-		if (price === undefined) {
-			return undefined;
-		}
-		const isStale = this.feedIdToIsStale.get(feedId) ?? false;
-		return { price, isStale };
-	}
 }