@drift-labs/sdk 2.71.0-beta.3 → 2.71.0-beta.5

package/src/math/oracles.ts

@@ -1,4 +1,4 @@
-import { AMM, OracleGuardRails } from '../types';
+import { AMM, OracleGuardRails, isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import {
 	BID_ASK_SPREAD_PRECISION,
@@ -27,12 +27,33 @@ export function oraclePriceBands(
 	return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
 }
 
+export function getMaxConfidenceIntervalMultiplier(
+	market: PerpMarketAccount
+): BN {
+	let maxConfidenceIntervalMultiplier;
+	if (isVariant(market.contractTier, 'a')) {
+		maxConfidenceIntervalMultiplier = new BN(1);
+	} else if (isVariant(market.contractTier, 'b')) {
+		maxConfidenceIntervalMultiplier = new BN(1);
+	} else if (isVariant(market.contractTier, 'c')) {
+		maxConfidenceIntervalMultiplier = new BN(2);
+	} else if (isVariant(market.contractTier, 'speculative')) {
+		maxConfidenceIntervalMultiplier = new BN(10);
+	} else if (isVariant(market.contractTier, 'isolated')) {
+		maxConfidenceIntervalMultiplier = new BN(50);
+	}
+	return maxConfidenceIntervalMultiplier;
+}
+
 export function isOracleValid(
-	amm: AMM,
+	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
 	oracleGuardRails: OracleGuardRails,
 	slot: number
 ): boolean {
+	// checks if oracle is valid for an AMM only fill
+
+	const amm = market.amm;
 	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
 	const isOraclePriceTooVolatile =
 		oraclePriceData.price
@@ -42,10 +63,16 @@ export function isOracleValid(
 			.div(BN.max(ONE, oraclePriceData.price))
 			.gt(oracleGuardRails.validity.tooVolatileRatio);
 
+	const maxConfidenceIntervalMultiplier =
+		getMaxConfidenceIntervalMultiplier(market);
 	const isConfidenceTooLarge = BN.max(ONE, oraclePriceData.confidence)
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(oraclePriceData.price)
-		.gt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+		.gt(
+			oracleGuardRails.validity.confidenceIntervalMaxSize.mul(
+				maxConfidenceIntervalMultiplier
+			)
+		);
 
 	const oracleIsStale = new BN(slot)
 		.sub(oraclePriceData.slot)

package/src/oracles/switchboardClient.ts

@@ -0,0 +1,77 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { OracleClient, OraclePriceData } from './types';
+import switchboardV2Idl from '../idl/switchboard.json';
+import { BorshAccountsCoder, BN, Idl } from '@coral-xyz/anchor';
+
+type SwitchboardDecimal = {
+	scale: number;
+	mantissa: BN;
+};
+
+type AggregatorAccountData = {
+	latestConfirmedRound: {
+		result: SwitchboardDecimal;
+		stdDeviation: SwitchboardDecimal;
+		numSuccess: number;
+		roundOpenSlot: BN;
+	};
+	minOracleResults: number;
+};
+
+export class SwitchboardClient implements OracleClient {
+	connection: Connection;
+	coder: BorshAccountsCoder;
+
+	public constructor(connection: Connection) {
+		this.connection = connection;
+		this.coder = new BorshAccountsCoder(switchboardV2Idl as Idl);
+	}
+
+	public async getOraclePriceData(
+		pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+	}
+
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
+		const aggregatorAccountData = this.coder.decodeUnchecked(
+			'AggregatorAccountData',
+			buffer
+		) as AggregatorAccountData;
+
+		const price = convertSwitchboardDecimal(
+			aggregatorAccountData.latestConfirmedRound.result
+		);
+
+		const confidence = BN.max(
+			convertSwitchboardDecimal(
+				aggregatorAccountData.latestConfirmedRound.stdDeviation
+			),
+			price.divn(1000)
+		);
+
+		const hasSufficientNumberOfDataPoints =
+			aggregatorAccountData.latestConfirmedRound.numSuccess >=
+			aggregatorAccountData.minOracleResults;
+
+		const slot: BN = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+		return {
+			price,
+			slot,
+			confidence,
+			hasSufficientNumberOfDataPoints,
+		};
+	}
+}
+
+function convertSwitchboardDecimal(switchboardDecimal: {
+	scale: number;
+	mantissa: BN;
+}): BN {
+	const switchboardPrecision = TEN.pow(new BN(switchboardDecimal.scale));
+	return switchboardDecimal.mantissa
+		.mul(PRICE_PRECISION)
+		.div(switchboardPrecision);
+}

package/src/types.ts

@@ -93,7 +93,7 @@ export class OracleSource {
 	static readonly PYTH = { pyth: {} };
 	static readonly PYTH_1K = { pyth1K: {} };
 	static readonly PYTH_1M = { pyth1M: {} };
-	// static readonly SWITCHBOARD = { switchboard: {} };
+	static readonly SWITCHBOARD = { switchboard: {} };
 	static readonly QUOTE_ASSET = { quoteAsset: {} };
 	static readonly PYTH_STABLE_COIN = { pythStableCoin: {} };
 	static readonly Prelaunch = { prelaunch: {} };

package/tests/amm/test.ts

@@ -1193,12 +1193,12 @@ describe('AMM Tests', () => {
 		};
 
 		// good oracle
-		assert(isOracleValid(mockAmm, oraclePriceData, oracleGuardRails, slot + 5));
+		assert(isOracleValid(mockMarket1, oraclePriceData, oracleGuardRails, slot + 5));
 
 		// conf too high
 		assert(
 			!isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot),
@@ -1213,7 +1213,7 @@ describe('AMM Tests', () => {
 		// not hasSufficientNumberOfDataPoints
 		assert(
 			!isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot),
@@ -1228,7 +1228,7 @@ describe('AMM Tests', () => {
 		// negative oracle price
 		assert(
 			!isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(-1 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot),
@@ -1243,7 +1243,7 @@ describe('AMM Tests', () => {
 		// too delayed for amm
 		assert(
 			!isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot),
@@ -1258,7 +1258,7 @@ describe('AMM Tests', () => {
 		// im passing stale slot (should not call oracle invalid)
 		assert(
 			isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot + 100),
@@ -1273,7 +1273,7 @@ describe('AMM Tests', () => {
 		// too volatile (more than 5x higher)
 		assert(
 			!isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(113.553 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot + 5),
@@ -1288,7 +1288,7 @@ describe('AMM Tests', () => {
 		// too volatile (more than 1/5 lower)
 		assert(
 			!isOracleValid(
-				mockAmm,
+				mockMarket1,
 				{
 					price: new BN(0.553 * PRICE_PRECISION.toNumber()),
 					slot: new BN(slot + 5),