@drift-labs/sdk-browser 2.104.0-beta.21

package/src/oracles/pythPullClient.ts

@@ -0,0 +1,111 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { AnchorProvider, BN, Program } from '@coral-xyz/anchor';
+import {
+	ONE,
+	PRICE_PRECISION,
+	QUOTE_PRECISION,
+	TEN,
+} from '../constants/numericConstants';
+import {
+	PythSolanaReceiverProgram,
+	pythSolanaReceiverIdl,
+} from '@pythnetwork/pyth-solana-receiver';
+import { PriceUpdateAccount } from '@pythnetwork/pyth-solana-receiver/lib/PythSolanaReceiver';
+import { DRIFT_ORACLE_RECEIVER_ID, Wallet } from '..';
+
+export class PythPullClient implements OracleClient {
+	private connection: Connection;
+	private multiple: BN;
+	private stableCoin: boolean;
+	readonly receiver: Program<PythSolanaReceiverProgram>;
+	readonly decodeFunc: (name: string, data: Buffer) => PriceUpdateAccount;
+
+	public constructor(
+		connection: Connection,
+		multiple = ONE,
+		stableCoin = false
+	) {
+		this.connection = connection;
+		this.multiple = multiple;
+		this.stableCoin = stableCoin;
+		const provider = new AnchorProvider(
+			this.connection,
+			//@ts-ignore
+			new Wallet(new Keypair()),
+			{
+				commitment: connection.commitment,
+			}
+		);
+		this.receiver = new Program<PythSolanaReceiverProgram>(
+			pythSolanaReceiverIdl as PythSolanaReceiverProgram,
+			DRIFT_ORACLE_RECEIVER_ID,
+			provider
+		);
+		this.decodeFunc =
+			this.receiver.account.priceUpdateV2.coder.accounts.decodeUnchecked.bind(
+				this.receiver.account.priceUpdateV2.coder.accounts
+			);
+	}
+
+	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 message = this.decodeFunc('priceUpdateV2', buffer);
+		const priceData = message.priceMessage;
+		const confidence = convertPythPrice(
+			priceData.conf,
+			priceData.exponent,
+			this.multiple
+		);
+		let price = convertPythPrice(
+			priceData.price,
+			priceData.exponent,
+			this.multiple
+		);
+		if (this.stableCoin) {
+			price = getStableCoinPrice(price, confidence);
+		}
+
+		return {
+			price,
+			slot: message.postedSlot,
+			confidence,
+			twap: convertPythPrice(
+				priceData.price,
+				priceData.exponent,
+				this.multiple
+			),
+			twapConfidence: convertPythPrice(
+				priceData.price,
+				priceData.exponent,
+				this.multiple
+			),
+			hasSufficientNumberOfDataPoints: true,
+		};
+	}
+}
+
+export function convertPythPrice(
+	price: BN,
+	exponent: number,
+	multiple: BN
+): BN {
+	exponent = Math.abs(exponent);
+	const pythPrecision = TEN.pow(new BN(exponent).abs()).div(multiple);
+	return price.mul(PRICE_PRECISION).div(pythPrecision);
+}
+
+const fiveBPS = new BN(500);
+function getStableCoinPrice(price: BN, confidence: BN): BN {
+	if (price.sub(QUOTE_PRECISION).abs().lt(BN.min(confidence, fiveBPS))) {
+		return QUOTE_PRECISION;
+	} else {
+		return price;
+	}
+}

package/src/oracles/quoteAssetOracleClient.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@coral-xyz/anchor';
+import { PRICE_PRECISION } from '../constants/numericConstants';
+
+export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
+	price: PRICE_PRECISION,
+	slot: new BN(0),
+	confidence: new BN(1),
+	hasSufficientNumberOfDataPoints: true,
+};
+
+export class QuoteAssetOracleClient implements OracleClient {
+	public constructor() {}
+
+	public async getOraclePriceData(
+		_pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		return Promise.resolve(QUOTE_ORACLE_PRICE_DATA);
+	}
+
+	public getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData {
+		return QUOTE_ORACLE_PRICE_DATA;
+	}
+}

package/src/oracles/strictOraclePrice.ts

@@ -0,0 +1,19 @@
+import { BN } from '@coral-xyz/anchor';
+
+export class StrictOraclePrice {
+	current: BN;
+	twap?: BN;
+
+	constructor(current: BN, twap?: BN) {
+		this.current = current;
+		this.twap = twap;
+	}
+
+	public max(): BN {
+		return this.twap ? BN.max(this.twap, this.current) : this.current;
+	}
+
+	public min(): BN {
+		return this.twap ? BN.min(this.twap, this.current) : this.current;
+	}
+}

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/oracles/switchboardOnDemandClient.ts

@@ -0,0 +1,56 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@coral-xyz/anchor';
+import switchboardOnDemandIdl from '../idl/switchboard_on_demand_30.json';
+import { PRICE_PRECISION_EXP } from '../constants/numericConstants';
+import {
+	BorshAccountsCoder as BorshAccountsCoder30,
+	Idl as Idl30,
+} from '@coral-xyz/anchor-30';
+
+const SB_PRECISION_EXP = new BN(18);
+const SB_PRECISION = new BN(10).pow(SB_PRECISION_EXP.sub(PRICE_PRECISION_EXP));
+
+type PullFeedAccountData = {
+	result: {
+		value: BN;
+		std_dev: BN;
+		mean: BN;
+		slot: BN;
+		range: BN;
+	};
+	last_update_timestamp: BN;
+	max_variance: BN;
+	min_responses: BN;
+};
+
+export class SwitchboardOnDemandClient implements OracleClient {
+	connection: Connection;
+	coder: BorshAccountsCoder30;
+
+	public constructor(connection: Connection) {
+		this.connection = connection;
+		this.coder = new BorshAccountsCoder30(switchboardOnDemandIdl as Idl30);
+	}
+
+	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 pullFeedAccountData = this.coder.decodeUnchecked(
+			'PullFeedAccountData',
+			buffer
+		) as PullFeedAccountData;
+
+		return {
+			price: pullFeedAccountData.result.value.div(SB_PRECISION),
+			slot: pullFeedAccountData.result.slot,
+			confidence: pullFeedAccountData.result.range.div(SB_PRECISION),
+			hasSufficientNumberOfDataPoints: true,
+		};
+	}
+}

package/src/oracles/types.ts

@@ -0,0 +1,23 @@
+import { BN } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
+
+export type OraclePriceData = {
+	price: BN;
+	slot: BN;
+	confidence: BN;
+	hasSufficientNumberOfDataPoints: boolean;
+	twap?: BN;
+	twapConfidence?: BN;
+	maxPrice?: BN; // pre-launch markets only
+};
+
+export type OracleInfo = {
+	publicKey: PublicKey;
+	source: OracleSource;
+};
+
+export interface OracleClient {
+	getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+	getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
+}

package/src/orderParams.ts

@@ -0,0 +1,79 @@
+import {
+	DefaultOrderParams,
+	OptionalOrderParams,
+	OrderParams,
+	OrderTriggerCondition,
+	OrderType,
+} from './types';
+import { BN } from '@coral-xyz/anchor';
+
+export function getLimitOrderParams(
+	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
+): OptionalOrderParams {
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.LIMIT,
+		})
+	);
+}
+
+export function getTriggerMarketOrderParams(
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+	}
+): OptionalOrderParams {
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.TRIGGER_MARKET,
+		})
+	);
+}
+
+export function getTriggerLimitOrderParams(
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+		price: BN;
+	}
+): OptionalOrderParams {
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.TRIGGER_LIMIT,
+		})
+	);
+}
+
+export function getMarketOrderParams(
+	params: Omit<OptionalOrderParams, 'orderType'>
+): OptionalOrderParams {
+	return getOrderParams(
+		Object.assign({}, params, {
+			orderType: OrderType.MARKET,
+		})
+	);
+}
+
+/**
+ * Creates an OrderParams object with the given OptionalOrderParams and any params to override.
+ *
+ * example:
+ * ```
+ * const orderParams = getOrderParams(optionalOrderParams, { marketType: MarketType.PERP });
+ * ```
+ *
+ * @param optionalOrderParams
+ * @param overridingParams
+ * @returns
+ */
+export function getOrderParams(
+	optionalOrderParams: OptionalOrderParams,
+	overridingParams: Record<string, any> = {}
+): OrderParams {
+	return Object.assign(
+		{},
+		DefaultOrderParams,
+		optionalOrderParams,
+		overridingParams
+	);
+}

package/src/orderSubscriber/OrderSubscriber.ts

@@ -0,0 +1,249 @@
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { getUserFilter, getUserWithOrderFilter } from '../memcmp';
+import { Commitment, PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import { DLOB } from '../dlob/DLOB';
+import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
+import { PollingSubscription } from './PollingSubscription';
+import { WebsocketSubscription } from './WebsocketSubscription';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { BN } from '../index';
+import { decodeUser } from '../decode/user';
+import { grpcSubscription } from './grpcSubscription';
+import { isUserProtectedMaker } from '../math/userStatus';
+
+export class OrderSubscriber {
+	driftClient: DriftClient;
+	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
+	subscription: PollingSubscription | WebsocketSubscription | grpcSubscription;
+	commitment: Commitment;
+	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
+
+	fetchPromise?: Promise<void>;
+	fetchPromiseResolver: () => void;
+
+	mostRecentSlot: number;
+	decodeFn: (name: string, data: Buffer) => UserAccount;
+	decodeData?: boolean;
+
+	constructor(config: OrderSubscriberConfig) {
+		this.driftClient = config.driftClient;
+		this.commitment = config.subscriptionConfig.commitment || 'processed';
+		if (config.subscriptionConfig.type === 'polling') {
+			this.subscription = new PollingSubscription({
+				orderSubscriber: this,
+				frequency: config.subscriptionConfig.frequency,
+			});
+		} else if (config.subscriptionConfig.type === 'grpc') {
+			this.subscription = new grpcSubscription({
+				orderSubscriber: this,
+				grpcConfigs: config.subscriptionConfig.grpcConfigs,
+				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig?.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig?.logResubMessages,
+				},
+				resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
+				decoded: config.decodeData,
+			});
+		} else {
+			this.subscription = new WebsocketSubscription({
+				orderSubscriber: this,
+				commitment: this.commitment,
+				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig?.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig?.logResubMessages,
+				},
+				resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
+				decoded: config.decodeData,
+			});
+		}
+		if (config.fastDecode ?? true) {
+			this.decodeFn = (name, data) => decodeUser(data);
+		} else {
+			this.decodeFn =
+				this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.driftClient.program.account.user.coder.accounts
+				);
+		}
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public async subscribe(): Promise<void> {
+		await this.subscription.subscribe();
+	}
+
+	async fetch(): Promise<void> {
+		if (this.fetchPromise) {
+			return this.fetchPromise;
+		}
+
+		this.fetchPromise = new Promise((resolver) => {
+			this.fetchPromiseResolver = resolver;
+		});
+
+		try {
+			const rpcRequestArgs = [
+				this.driftClient.program.programId.toBase58(),
+				{
+					commitment: this.commitment,
+					filters: [getUserFilter(), getUserWithOrderFilter()],
+					encoding: 'base64',
+					withContext: true,
+				},
+			];
+
+			const rpcJSONResponse: any =
+				// @ts-ignore
+				await this.driftClient.connection._rpcRequest(
+					'getProgramAccounts',
+					rpcRequestArgs
+				);
+
+			const rpcResponseAndContext: RpcResponseAndContext<
+				Array<{
+					pubkey: PublicKey;
+					account: {
+						data: [string, string];
+					};
+				}>
+			> = rpcJSONResponse.result;
+
+			const slot: number = rpcResponseAndContext.context.slot;
+
+			for (const programAccount of rpcResponseAndContext.value) {
+				const key = programAccount.pubkey.toString();
+				this.tryUpdateUserAccount(
+					key,
+					'raw',
+					programAccount.account.data,
+					slot
+				);
+				// give event loop a chance to breathe
+				await new Promise((resolve) => setTimeout(resolve, 0));
+			}
+		} catch (e) {
+			console.error(e);
+		} finally {
+			this.fetchPromiseResolver();
+			this.fetchPromise = undefined;
+		}
+	}
+
+	tryUpdateUserAccount(
+		key: string,
+		dataType: 'raw' | 'decoded' | 'buffer',
+		data: string[] | UserAccount | Buffer,
+		slot: number
+	): void {
+		if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
+			this.mostRecentSlot = slot;
+		}
+
+		this.eventEmitter.emit(
+			'updateReceived',
+			new PublicKey(key),
+			slot,
+			dataType
+		);
+
+		const slotAndUserAccount = this.usersAccounts.get(key);
+		if (!slotAndUserAccount || slotAndUserAccount.slot <= slot) {
+			let userAccount: UserAccount;
+			// Polling leads to a lot of redundant decoding, so we only decode if data is from a fresh slot
+			if (dataType === 'raw') {
+				// @ts-ignore
+				const buffer = Buffer.from(data[0], data[1]);
+
+				const newLastActiveSlot = new BN(
+					buffer.subarray(4328, 4328 + 8),
+					undefined,
+					'le'
+				);
+				if (
+					slotAndUserAccount &&
+					slotAndUserAccount.userAccount.lastActiveSlot.gt(newLastActiveSlot)
+				) {
+					return;
+				}
+
+				userAccount = this.decodeFn('User', buffer) as UserAccount;
+			} else if (dataType === 'buffer') {
+				const buffer: Buffer = data as Buffer;
+				const newLastActiveSlot = new BN(
+					buffer.subarray(4328, 4328 + 8),
+					undefined,
+					'le'
+				);
+				if (
+					slotAndUserAccount &&
+					slotAndUserAccount.userAccount.lastActiveSlot.gt(newLastActiveSlot)
+				) {
+					return;
+				}
+
+				userAccount = this.decodeFn('User', data as Buffer) as UserAccount;
+			} else {
+				userAccount = data as UserAccount;
+			}
+
+			this.eventEmitter.emit(
+				'userUpdated',
+				userAccount,
+				new PublicKey(key),
+				slot,
+				dataType
+			);
+
+			const newOrders = userAccount.orders.filter(
+				(order) =>
+					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&
+					order.slot.toNumber() <= slot
+			);
+			if (newOrders.length > 0) {
+				this.eventEmitter.emit(
+					'orderCreated',
+					userAccount,
+					newOrders,
+					new PublicKey(key),
+					slot,
+					dataType
+				);
+			}
+
+			this.usersAccounts.set(key, { slot, userAccount });
+		}
+	}
+
+	/**
+	 * Creates a new DLOB for the order subscriber to fill. This will allow a
+	 * caller to extend the DLOB Subscriber with a custom DLOB type.
+	 * @returns New, empty DLOB object.
+	 */
+	protected createDLOB(): DLOB {
+		return new DLOB();
+	}
+
+	public async getDLOB(slot: number): Promise<DLOB> {
+		const dlob = this.createDLOB();
+		for (const [key, { userAccount }] of this.usersAccounts.entries()) {
+			const protectedMaker = isUserProtectedMaker(userAccount);
+			for (const order of userAccount.orders) {
+				dlob.insertOrder(order, key, slot, protectedMaker);
+			}
+		}
+		return dlob;
+	}
+
+	public getSlot(): number {
+		return this.mostRecentSlot ?? 0;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		this.usersAccounts.clear();
+		await this.subscription.unsubscribe();
+	}
+}

package/src/orderSubscriber/PollingSubscription.ts

@@ -0,0 +1,39 @@
+import { OrderSubscriber } from './OrderSubscriber';
+
+export class PollingSubscription {
+	private orderSubscriber: OrderSubscriber;
+	private frequency: number;
+
+	intervalId?: ReturnType<typeof setTimeout>;
+
+	constructor({
+		orderSubscriber,
+		frequency,
+	}: {
+		orderSubscriber: OrderSubscriber;
+		frequency: number;
+	}) {
+		this.orderSubscriber = orderSubscriber;
+		this.frequency = frequency;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		this.intervalId = setInterval(
+			this.orderSubscriber.fetch.bind(this.orderSubscriber),
+			this.frequency
+		);
+
+		await this.orderSubscriber.fetch();
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}