@drift-labs/sdk 2.49.0-beta.1 → 2.49.0-beta.10

package/src/accounts/pollingInsuranceFundStakeAccountSubscriber.ts

@@ -0,0 +1,185 @@
+import {
+	DataAndSlot,
+	NotSubscribedError,
+	InsuranceFundStakeAccountEvents,
+	InsuranceFundStakeAccountSubscriber,
+} from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { InsuranceFundStake } from '../types';
+
+export class PollingInsuranceFundStakeAccountSubscriber
+	implements InsuranceFundStakeAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	insuranceFundStakeAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	callbackId?: string;
+	errorCallbackId?: string;
+
+	insuranceFundStakeAccountAndSlot?: DataAndSlot<InsuranceFundStake>;
+
+	public constructor(
+		program: Program,
+		publicKey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.insuranceFundStakeAccountPublicKey = publicKey;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(insuranceFundStake?: InsuranceFundStake): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		if (insuranceFundStake) {
+			this.insuranceFundStakeAccountAndSlot = {
+				data: insuranceFundStake,
+				slot: undefined,
+			};
+		}
+
+		await this.addToAccountLoader();
+
+		if (this.doesAccountExist()) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.callbackId) {
+			return;
+		}
+
+		this.callbackId = await this.accountLoader.addAccount(
+			this.insuranceFundStakeAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
+
+				if (
+					this.insuranceFundStakeAccountAndSlot &&
+					this.insuranceFundStakeAccountAndSlot.slot > slot
+				) {
+					return;
+				}
+
+				const account = this.program.account.user.coder.accounts.decode(
+					'InsuranceFundStake',
+					buffer
+				);
+				this.insuranceFundStakeAccountAndSlot = { data: account, slot };
+				this.eventEmitter.emit('insuranceFundStakeAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		if (this.insuranceFundStakeAccountAndSlot === undefined) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			const dataAndContext =
+				await this.program.account.insuranceFundStake.fetchAndContext(
+					this.insuranceFundStakeAccountPublicKey,
+					this.accountLoader.commitment
+				);
+			if (
+				dataAndContext.context.slot >
+				(this.insuranceFundStakeAccountAndSlot?.slot ?? 0)
+			) {
+				this.insuranceFundStakeAccountAndSlot = {
+					data: dataAndContext.data as InsuranceFundStake,
+					slot: dataAndContext.context.slot,
+				};
+			}
+		} catch (e) {
+			console.log(
+				`PollingInsuranceFundStakeAccountSubscriber.fetch() InsuranceFundStake does not exist: ${e.message}`
+			);
+		}
+	}
+
+	doesAccountExist(): boolean {
+		return this.insuranceFundStakeAccountAndSlot !== undefined;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(
+			this.insuranceFundStakeAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake> {
+		this.assertIsSubscribed();
+		return this.insuranceFundStakeAccountAndSlot;
+	}
+
+	didSubscriptionSucceed(): boolean {
+		return !!this.insuranceFundStakeAccountAndSlot;
+	}
+
+	public updateData(
+		insuranceFundStake: InsuranceFundStake,
+		slot: number
+	): void {
+		if (
+			!this.insuranceFundStakeAccountAndSlot ||
+			this.insuranceFundStakeAccountAndSlot.slot < slot
+		) {
+			this.insuranceFundStakeAccountAndSlot = {
+				data: insuranceFundStake,
+				slot,
+			};
+			this.eventEmitter.emit(
+				'insuranceFundStakeAccountUpdate',
+				insuranceFundStake
+			);
+			this.eventEmitter.emit('update');
+		}
+	}
+}

package/src/accounts/types.ts

@@ -5,6 +5,7 @@ import {
 	StateAccount,
 	UserAccount,
 	UserStatsAccount,
+	InsuranceFundStake,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -105,6 +106,26 @@ export interface TokenAccountSubscriber {
 	getTokenAccountAndSlot(): DataAndSlot<Account>;
 }
 
+export interface InsuranceFundStakeAccountSubscriber {
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake>;
+}
+
+export interface InsuranceFundStakeAccountEvents {
+	insuranceFundStakeAccountUpdate: (payload: InsuranceFundStake) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
 export interface OracleEvents {
 	oracleUpdate: (payload: OraclePriceData) => void;
 	update: void;

package/src/accounts/webSocketInsuranceFundStakeAccountSubscriber.ts

@@ -0,0 +1,127 @@
+import {
+	DataAndSlot,
+	AccountSubscriber,
+	NotSubscribedError,
+	InsuranceFundStakeAccountEvents,
+	InsuranceFundStakeAccountSubscriber,
+} from './types';
+import { Program } from '@coral-xyz/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { InsuranceFundStake } from '../types';
+
+export class WebSocketInsuranceFundStakeAccountSubscriber
+	implements InsuranceFundStakeAccountSubscriber
+{
+	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
+	commitment?: Commitment;
+	program: Program;
+	eventEmitter: StrictEventEmitter<
+		EventEmitter,
+		InsuranceFundStakeAccountEvents
+	>;
+	insuranceFundStakeAccountPublicKey: PublicKey;
+
+	insuranceFundStakeDataAccountSubscriber: AccountSubscriber<InsuranceFundStake>;
+
+	public constructor(
+		program: Program,
+		insuranceFundStakeAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number,
+		commitment?: Commitment
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.insuranceFundStakeAccountPublicKey =
+			insuranceFundStakeAccountPublicKey;
+		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
+		this.commitment = commitment;
+	}
+
+	async subscribe(
+		insuranceFundStakeAccount?: InsuranceFundStake
+	): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		this.insuranceFundStakeDataAccountSubscriber =
+			new WebSocketAccountSubscriber(
+				'insuranceFundStake',
+				this.program,
+				this.insuranceFundStakeAccountPublicKey,
+				undefined,
+				this.reconnectTimeoutMs,
+				this.commitment
+			);
+
+		if (insuranceFundStakeAccount) {
+			this.insuranceFundStakeDataAccountSubscriber.setData(
+				insuranceFundStakeAccount
+			);
+		}
+
+		await this.insuranceFundStakeDataAccountSubscriber.subscribe(
+			(data: InsuranceFundStake) => {
+				this.eventEmitter.emit('insuranceFundStakeAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async fetch(): Promise<void> {
+		await Promise.all([this.insuranceFundStakeDataAccountSubscriber.fetch()]);
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await Promise.all([
+			this.insuranceFundStakeDataAccountSubscriber.unsubscribe(),
+		]);
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getInsuranceFundStakeAccountAndSlot(): DataAndSlot<InsuranceFundStake> {
+		this.assertIsSubscribed();
+		return this.insuranceFundStakeDataAccountSubscriber.dataAndSlot;
+	}
+
+	public updateData(
+		insuranceFundStake: InsuranceFundStake,
+		slot: number
+	): void {
+		const currentDataSlot =
+			this.insuranceFundStakeDataAccountSubscriber.dataAndSlot?.slot || 0;
+		if (currentDataSlot <= slot) {
+			this.insuranceFundStakeDataAccountSubscriber.setData(
+				insuranceFundStake,
+				slot
+			);
+			this.eventEmitter.emit(
+				'insuranceFundStakeAccountUpdate',
+				insuranceFundStake
+			);
+			this.eventEmitter.emit('update');
+		}
+	}
+}

package/src/dlob/DLOB.ts

@@ -504,6 +504,9 @@ export class DLOB {
 			? stateAccount.minPerpAuctionDuration
 			: 0;
 
+		const { makerRebateNumerator, makerRebateDenominator } =
+			this.getMakerRebate(marketType, stateAccount, marketAccount);
+
 		const restingLimitOrderNodesToFill: Array<NodeToFill> =
 			this.findRestingLimitOrderNodesToFill(
 				marketIndex,
@@ -512,6 +515,8 @@ export class DLOB {
 				oraclePriceData,
 				isAmmPaused,
 				minAuctionDuration,
+				makerRebateNumerator,
+				makerRebateDenominator,
 				fallbackAsk,
 				fallbackBid
 			);
@@ -549,6 +554,34 @@ export class DLOB {
 		).concat(expiredNodesToFill);
 	}
 
+	getMakerRebate(
+		marketType: MarketType,
+		stateAccount: StateAccount,
+		marketAccount: PerpMarketAccount | SpotMarketAccount
+	): { makerRebateNumerator: number; makerRebateDenominator: number } {
+		let makerRebateNumerator: number;
+		let makerRebateDenominator: number;
+		if (isVariant(marketType, 'perp')) {
+			makerRebateNumerator =
+				stateAccount.perpFeeStructure.feeTiers[0].makerRebateNumerator;
+			makerRebateDenominator =
+				stateAccount.perpFeeStructure.feeTiers[0].makerRebateDenominator;
+		} else {
+			makerRebateNumerator =
+				stateAccount.spotFeeStructure.feeTiers[0].makerRebateNumerator;
+			makerRebateDenominator =
+				stateAccount.spotFeeStructure.feeTiers[0].makerRebateDenominator;
+		}
+
+		// @ts-ignore
+		const feeAdjustment = marketAccount.feeAdjustment || 0;
+		if (feeAdjustment !== 0) {
+			makerRebateNumerator += (makerRebateNumerator * feeAdjustment) / 100;
+		}
+
+		return { makerRebateNumerator, makerRebateDenominator };
+	}
+
 	mergeNodesToFill(
 		restingLimitOrderNodesToFill: NodeToFill[],
 		takingOrderNodesToFill: NodeToFill[]
@@ -590,6 +623,8 @@ export class DLOB {
 		oraclePriceData: OraclePriceData,
 		isAmmPaused: boolean,
 		minAuctionDuration: number,
+		makerRebateNumerator: number,
+		makerRebateDenominator: number,
 		fallbackAsk: BN | undefined,
 		fallbackBid: BN | undefined
 	): NodeToFill[] {
@@ -613,14 +648,18 @@ export class DLOB {
 				marketType,
 				oraclePriceData
 			);
+
+			const fallbackBidWithBuffer = fallbackBid.sub(
+				fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator)
+			);
+
 			const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(
 				marketType,
 				slot,
 				oraclePriceData,
 				askGenerator,
-				fallbackBid,
-				(askPrice, fallbackPrice) => {
-					return askPrice.lte(fallbackPrice);
+				(askPrice) => {
+					return askPrice.lte(fallbackBidWithBuffer);
 				},
 				minAuctionDuration
 			);
@@ -637,14 +676,18 @@ export class DLOB {
 				marketType,
 				oraclePriceData
 			);
+
+			const fallbackAskWithBuffer = fallbackAsk.add(
+				fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator)
+			);
+
 			const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(
 				marketType,
 				slot,
 				oraclePriceData,
 				bidGenerator,
-				fallbackAsk,
-				(bidPrice, fallbackPrice) => {
-					return bidPrice.gte(fallbackPrice);
+				(bidPrice) => {
+					return bidPrice.gte(fallbackAskWithBuffer);
 				},
 				minAuctionDuration
 			);
@@ -713,9 +756,8 @@ export class DLOB {
 					slot,
 					oraclePriceData,
 					takingOrderGenerator,
-					fallbackBid,
-					(takerPrice, fallbackPrice) => {
-						return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+					(takerPrice) => {
+						return takerPrice === undefined || takerPrice.lte(fallbackBid);
 					},
 					minAuctionDuration
 				);
@@ -771,9 +813,8 @@ export class DLOB {
 					slot,
 					oraclePriceData,
 					takingOrderGenerator,
-					fallbackAsk,
-					(takerPrice, fallbackPrice) => {
-						return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+					(takerPrice) => {
+						return takerPrice === undefined || takerPrice.gte(fallbackAsk);
 					},
 					minAuctionDuration
 				);
@@ -875,8 +916,7 @@ export class DLOB {
 		slot: number,
 		oraclePriceData: OraclePriceData,
 		nodeGenerator: Generator<DLOBNode>,
-		fallbackPrice: BN,
-		doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean,
+		doesCross: (nodePrice: BN | undefined) => boolean,
 		minAuctionDuration: number
 	): NodeToFill[] {
 		const nodesToFill = new Array<NodeToFill>();
@@ -893,7 +933,7 @@ export class DLOB {
 			const nodePrice = getLimitPrice(node.order, oraclePriceData, slot);
 
 			// order crosses if there is no limit price or it crosses fallback price
-			const crosses = doesCross(nodePrice, fallbackPrice);
+			const crosses = doesCross(nodePrice);
 
 			// fallback is available if auction is complete or it's a spot order
 			const fallbackAvailable =