Oracle Integration

import { DriftClient, convertToNumber, PRICE_PRECISION } from '@drift-labs/sdk';

// Get oracle data for SOL-PERP (market 0)
const oracleData = driftClient.getOracleDataForPerpMarket(0);

console.log('Price:', convertToNumber(oracleData.price, PRICE_PRECISION));
console.log('Slot:', oracleData.slot);
console.log('Confidence:', convertToNumber(oracleData.confidence, PRICE_PRECISION));
console.log('Has sufficient samples:', oracleData.hasSufficientNumberOfDataPoints);

// Get oracle data with slot information
const { data: oracleDataWithSlot, slot } = driftClient.getOraclePriceDataAndSlot(
  driftClient.getPerpMarketAccount(0).amm.oracle
);

if (oracleDataWithSlot) {
  console.log('Oracle price at slot', slot, ':', oracleDataWithSlot.price.toString());
}

// Get oracle data for SOL spot market (market 1)
const spotMarket = driftClient.getSpotMarketAccount(1);
const oracleData = driftClient.getOracleDataForSpotMarket(1);

console.log('SOL spot oracle price:', convertToNumber(oracleData.price, PRICE_PRECISION));
console.log('Oracle source:', spotMarket.oracleSource); // e.g., OracleSource.PYTH

interface OraclePriceData {
  price: BN;                                // Current price
  slot: number;                            // Slot number
  confidence: BN;                          // Confidence interval
  twap: BN | null;                        // Time-weighted average price
  twapConfidence: BN | null;              // TWAP confidence
  hasSufficientNumberOfDataPoints: boolean; // Data quality flag
}

import { isOracleValid } from '@drift-labs/sdk';

const perpMarket = driftClient.getPerpMarketAccount(0);
const oracleData = driftClient.getOracleDataForPerpMarket(0);
const currentSlot = await driftClient.connection.getSlot();

const isValid = isOracleValid(
  perpMarket.amm,
  oracleData,
  driftClient.getStateAccount().oracleGuardRails,
  currentSlot
);

if (!isValid) {
  console.warn('⚠️ Oracle data is invalid or stale!');
}

import { isOracleTooDivergent } from '@drift-labs/sdk';

// Check if oracle price diverges too much from AMM
const perpMarket = driftClient.getPerpMarketAccount(0);
const oracleData = driftClient.getOracleDataForPerpMarket(0);

const divergenceCheck = isOracleTooDivergent(
  oracleData.price,
  perpMarket.amm,
  driftClient.getStateAccount().oracleGuardRails
);

if (divergenceCheck.tooDivergent) {
  console.warn('Oracle price diverges from AMM!');
  console.log('Oracle price:', divergenceCheck.oraclePrice.toString());
  console.log('Mark price:', divergenceCheck.markPrice.toString());
}

const state = driftClient.getStateAccount();
const guardRails = state.oracleGuardRails;

console.log('Slots before stale:', guardRails.slotsBeforeStaleForAmm);
console.log('Confidence interval max:', guardRails.confidenceIntervalMaxPercentDivergence);
console.log('Max divergence:', guardRails.priceDivergence.markOraclePercentDivergence);

import { PublicKey } from '@solana/web3.js';

// Get price update from Pyth Hermes API
const response = await fetch(
  `https://hermes.pyth.network/api/latest_price_feeds?ids[]=${feedId}`
);
const priceData = await response.json();

// Post price update on-chain
const priceUpdateAccount = /* ... */;
await driftClient.postPythPullOracleUpdate(priceUpdateAccount, priceData);

import { PythLazerSubscriber } from '@drift-labs/sdk';

// Subscribe to Pyth Lazer feeds
const pythLazer = new PythLazerSubscriber({
  connection: driftClient.connection,
  // Lazer configuration
});

await pythLazer.subscribe();

import { calculateBidAskPrice, convertToNumber } from '@drift-labs/sdk';

const perpMarket = driftClient.getPerpMarketAccount(0);
const oracleData = driftClient.getOracleDataForPerpMarket(0);

const [bidPrice, askPrice] = calculateBidAskPrice(
  perpMarket.amm,
  oracleData
);

console.log('Bid price:', convertToNumber(bidPrice, PRICE_PRECISION));
console.log('Ask price:', convertToNumber(askPrice, PRICE_PRECISION));
console.log('Spread:', convertToNumber(askPrice.sub(bidPrice), PRICE_PRECISION));

import { calculateReservePrice } from '@drift-labs/sdk';

const perpMarket = driftClient.getPerpMarketAccount(0);
const markPrice = calculateReservePrice(perpMarket, oracleData);

console.log('Mark price:', convertToNumber(markPrice, PRICE_PRECISION));

import { convertToNumber, PERCENTAGE_PRECISION } from '@drift-labs/sdk';

function monitorOracleHealth(driftClient: DriftClient, marketIndex: number) {
  const perpMarket = driftClient.getPerpMarketAccount(marketIndex);
  const oracleData = driftClient.getOracleDataForPerpMarket(marketIndex);
  const currentSlot = driftClient.getSlot();
  
  // Check staleness
  const slotsSinceUpdate = currentSlot - oracleData.slot;
  if (slotsSinceUpdate > 25) {
    console.warn(`Oracle stale by ${slotsSinceUpdate} slots`);
  }
  
  // Check confidence
  const confidencePercent = oracleData.confidence
    .mul(PERCENTAGE_PRECISION)
    .div(oracleData.price);
  
  if (confidencePercent.gt(new BN(1000))) { // > 0.1%
    console.warn(
      'High confidence interval:',
      convertToNumber(confidencePercent, PERCENTAGE_PRECISION),
      '%'
    );
  }
  
  // Check data quality
  if (!oracleData.hasSufficientNumberOfDataPoints) {
    console.warn('Insufficient oracle data points');
  }
  
  // Check divergence
  const markPrice = calculateReservePrice(perpMarket, oracleData);
  const divergence = markPrice.sub(oracleData.price).abs()
    .mul(PERCENTAGE_PRECISION)
    .div(oracleData.price);
  
  if (divergence.gt(new BN(100))) { // > 0.01%
    console.warn(
      'Mark/oracle divergence:',
      convertToNumber(divergence, PERCENTAGE_PRECISION),
      '%'
    );
  }
}

// Monitor continuously
setInterval(() => {
  monitorOracleHealth(driftClient, 0); // SOL-PERP
}, 5000);

const oracleData = driftClient.getOracleDataForPerpMarket(0);

if (oracleData.twap) {
  const twapPrice = convertToNumber(oracleData.twap, PRICE_PRECISION);
  const spotPrice = convertToNumber(oracleData.price, PRICE_PRECISION);
  
  console.log('TWAP price:', twapPrice);
  console.log('Spot price:', spotPrice);
  console.log('Difference:', Math.abs(twapPrice - spotPrice));
}

driftClient.eventEmitter.on('oraclePriceUpdate', (pubkey, source, data) => {
  console.log('Oracle update:');
  console.log('  Address:', pubkey.toBase58());
  console.log('  Source:', source);
  console.log('  Price:', convertToNumber(data.price, PRICE_PRECISION));
  console.log('  Slot:', data.slot);
  
  // Find which market uses this oracle
  const perpMarkets = driftClient.getPerpMarketAccounts();
  for (const market of perpMarkets) {
    if (market.amm.oracle.equals(pubkey)) {
      console.log('  Market:', market.name);
    }
  }
});