@drift-labs/sdk 2.25.4 → 2.26.0-beta.0

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -1,6 +1,5 @@
 import {
 	DataAndSlot,
-	AccountToPoll,
 	NotSubscribedError,
 	UserStatsAccountSubscriber,
 	UserStatsAccountEvents,
@@ -11,7 +10,6 @@ import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { UserStatsAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
-import { capitalize } from './utils';
 
 export class PollingUserStatsAccountSubscriber
 	implements UserStatsAccountSubscriber
@@ -22,7 +20,7 @@ export class PollingUserStatsAccountSubscriber
 	userStatsAccountPublicKey: PublicKey;
 
 	accountLoader: BulkAccountLoader;
-	accountsToPoll = new Map<string, AccountToPoll>();
+	callbackId?: string;
 	errorCallbackId?: string;
 
 	userStats?: DataAndSlot<UserStatsAccount>;
@@ -39,16 +37,20 @@ export class PollingUserStatsAccountSubscriber
 		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
 	}
 
-	async subscribe(): Promise<boolean> {
+	async subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean> {
 		if (this.isSubscribed) {
 			return true;
 		}
 
+		if (userStatsAccount) {
+			this.userStats = { data: userStatsAccount, slot: undefined };
+		}
+
 		await this.addToAccountLoader();
 
 		await this.fetchIfUnloaded();
 
-		if (this.doAccountsExist()) {
+		if (this.doesAccountExist()) {
 			this.eventEmitter.emit('update');
 		}
 
@@ -57,34 +59,30 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	async addToAccountLoader(): Promise<void> {
-		if (this.accountsToPoll.size > 0) {
+		if (this.callbackId !== undefined) {
 			return;
 		}
 
-		this.accountsToPoll.set(this.userStatsAccountPublicKey.toString(), {
-			key: 'userStats',
-			publicKey: this.userStatsAccountPublicKey,
-			eventType: 'userStatsAccountUpdate',
-		});
+		this.callbackId = await this.accountLoader.addAccount(
+			this.userStatsAccountPublicKey,
+			(buffer, slot: number) => {
+				if (!buffer) {
+					return;
+				}
 
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			accountToPoll.callbackId = await this.accountLoader.addAccount(
-				accountToPoll.publicKey,
-				(buffer, slot) => {
-					if (!buffer) {
-						return;
-					}
-
-					const account = this.program.account[
-						accountToPoll.key
-					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
-					this[accountToPoll.key] = { data: account, slot };
-					// @ts-ignore
-					this.eventEmitter.emit(accountToPoll.eventType, account);
-					this.eventEmitter.emit('update');
+				if (this.userStats && this.userStats.slot > slot) {
+					return;
 				}
-			);
-		}
+
+				const account = this.program.account.userStats.coder.accounts.decode(
+					'UserStats',
+					buffer
+				);
+				this.userStats = { data: account, slot };
+				this.eventEmitter.emit('userStatsAccountUpdate', account);
+				this.eventEmitter.emit('update');
+			}
+		);
 
 		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
 			this.eventEmitter.emit('error', error);
@@ -92,58 +90,44 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	async fetchIfUnloaded(): Promise<void> {
-		let shouldFetch = false;
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			if (this[accountToPoll.key] === undefined) {
-				shouldFetch = true;
-				break;
-			}
-		}
-
-		if (shouldFetch) {
+		if (this.userStats === undefined) {
 			await this.fetch();
 		}
 	}
 
 	async fetch(): Promise<void> {
 		await this.accountLoader.load();
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
-				accountToPoll.publicKey
+		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+			this.userStatsAccountPublicKey
+		);
+		const currentSlot = this.userStats?.slot ?? 0;
+		if (buffer && slot > currentSlot) {
+			const account = this.program.account.userStats.coder.accounts.decode(
+				'UserStats',
+				buffer
 			);
-			if (buffer) {
-				const account = this.program.account[
-					accountToPoll.key
-				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
-				this[accountToPoll.key] = { data: account, slot };
-			}
+			this.userStats = { data: account, slot };
 		}
 	}
 
-	doAccountsExist(): boolean {
-		let success = true;
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			if (!this[accountToPoll.key]) {
-				success = false;
-				break;
-			}
-		}
-		return success;
+	doesAccountExist(): boolean {
+		return this.userStats !== undefined;
 	}
 
 	async unsubscribe(): Promise<void> {
-		for (const [_, accountToPoll] of this.accountsToPoll) {
-			this.accountLoader.removeAccount(
-				accountToPoll.publicKey,
-				accountToPoll.callbackId
-			);
+		if (!this.isSubscribed) {
+			return;
 		}
 
+		this.accountLoader.removeAccount(
+			this.userStatsAccountPublicKey,
+			this.callbackId
+		);
+		this.callbackId = undefined;
+
 		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
 		this.errorCallbackId = undefined;
 
-		this.accountsToPoll.clear();
-
 		this.isSubscribed = false;
 	}
 

package/src/accounts/types.ts

@@ -18,7 +18,7 @@ export interface AccountSubscriber<T> {
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	setData(userAccount: T): void;
+	setData(userAccount: T, slot?: number): void;
 }
 
 export class NotSubscribedError extends Error {
@@ -73,6 +73,7 @@ export interface UserAccountSubscriber {
 
 	subscribe(userAccount?: UserAccount): Promise<boolean>;
 	fetch(): Promise<void>;
+	updateData(userAccount: UserAccount, slot: number): void;
 	unsubscribe(): Promise<void>;
 
 	getUserAccountAndSlot(): DataAndSlot<UserAccount>;

package/src/accounts/webSocketAccountSubscriber.ts

@@ -45,14 +45,15 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		);
 	}
 
-	setData(data: T): void {
-		if (this.dataAndSlot) {
+	setData(data: T, slot?: number): void {
+		const newSlot = slot || 0;
+		if (this.dataAndSlot && this.dataAndSlot.slot > newSlot) {
 			return;
 		}
 
 		this.dataAndSlot = {
 			data,
-			slot: undefined,
+			slot,
 		};
 	}
 

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -78,4 +78,14 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 		this.assertIsSubscribed();
 		return this.userDataAccountSubscriber.dataAndSlot;
 	}
+
+	public updateData(userAccount: UserAccount, slot: number) {
+		const currentDataSlot =
+			this.userDataAccountSubscriber.dataAndSlot?.slot || 0;
+		if (currentDataSlot < slot) {
+			this.userDataAccountSubscriber.setData(userAccount, slot);
+			this.eventEmitter.emit('userAccountUpdate', userAccount);
+			this.eventEmitter.emit('update');
+		}
+	}
 }

package/src/addresses/pda.ts

@@ -189,6 +189,19 @@ export function getSerumFulfillmentConfigPublicKey(
 	)[0];
 }
 
+export function getPhoenixFulfillmentConfigPublicKey(
+	programId: PublicKey,
+	market: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('phoenix_fulfillment_config')),
+			market.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
 export function getReferrerNamePublicKeySync(
 	programId: PublicKey,
 	nameBuffer: number[]

package/src/adminClient.ts

@@ -24,6 +24,7 @@ import {
 	getInsuranceFundVaultPublicKey,
 	getSerumOpenOrdersPublicKey,
 	getSerumFulfillmentConfigPublicKey,
+	getPhoenixFulfillmentConfigPublicKey,
 } from './addresses/pda';
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
@@ -31,6 +32,7 @@ import { DriftClient } from './driftClient';
 import { PEG_PRECISION } from './constants/numericConstants';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
+import { PROGRAM_ID as PHOENIX_PROGRAM_ID } from '@ellipsis-labs/phoenix-sdk';
 
 export class AdminClient extends DriftClient {
 	public async initialize(
@@ -181,6 +183,38 @@ export class AdminClient extends DriftClient {
 		return txSig;
 	}
 
+	public async initializePhoenixFulfillmentConfig(
+		marketIndex: number,
+		phoenixMarket: PublicKey
+	): Promise<TransactionSignature> {
+		const phoenixFulfillmentConfig = getPhoenixFulfillmentConfigPublicKey(
+			this.program.programId,
+			phoenixMarket
+		);
+
+		const tx =
+			await this.program.transaction.initializePhoenixFulfillmentConfig(
+				marketIndex,
+				{
+					accounts: {
+						admin: this.wallet.publicKey,
+						state: await this.getStatePublicKey(),
+						baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+						quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
+						driftSigner: this.getSignerPublicKey(),
+						phoenixMarket: phoenixMarket,
+						phoenixProgram: PHOENIX_PROGRAM_ID,
+						rent: SYSVAR_RENT_PUBKEY,
+						systemProgram: anchor.web3.SystemProgram.programId,
+						phoenixFulfillmentConfig,
+					},
+				}
+			);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
+
 	public async initializePerpMarket(
 		marketIndex: number,
 		priceOracle: PublicKey,

package/src/dlob/DLOBApiClient.ts

@@ -0,0 +1,37 @@
+import fetch from 'node-fetch';
+import { DLOBOrdersCoder } from './DLOBOrders';
+import { DLOB } from './DLOB';
+
+type DLOBApiClientConfig = {
+	url: string;
+};
+
+export class DLOBApiClient {
+	url: string;
+	dlobCoder = DLOBOrdersCoder.create();
+	lastSeenDLOB: DLOB;
+	lastSeenSlot = 0;
+
+	constructor(config: DLOBApiClientConfig) {
+		this.url = config.url;
+	}
+
+	public async getDLOB(slot: number): Promise<DLOB> {
+		const r = await fetch(this.url);
+		if (!r.ok) {
+			throw new Error(`Failed to fetch DLOB from ${this.url}`);
+		}
+
+		const resp = await r.json();
+		const responseSlot = resp['slot'];
+		if (responseSlot > this.lastSeenSlot) {
+			const dlobOrdersBuffer = Buffer.from(resp['data'], 'base64');
+			const dlobOrders = this.dlobCoder.decode(Buffer.from(dlobOrdersBuffer));
+			const dlob = new DLOB();
+			dlob.initFromOrders(dlobOrders, slot);
+			this.lastSeenDLOB = dlob;
+			this.lastSeenSlot = responseSlot;
+		}
+		return this.lastSeenDLOB;
+	}
+}

package/src/dlob/DLOBSubscriber.ts

@@ -0,0 +1,57 @@
+import { DLOB } from './DLOB';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import {
+	DLOBSource,
+	DLOBSubscriberEvents,
+	DLOBSubscriptionConfig,
+	SlotSource,
+} from './types';
+
+export class DLOBSubscriber {
+	dlobSource: DLOBSource;
+	slotSource: SlotSource;
+	updateFrequency: number;
+	intervalId?: NodeJS.Timeout;
+	dlob = new DLOB();
+	public eventEmitter: StrictEventEmitter<EventEmitter, DLOBSubscriberEvents>;
+
+	constructor(config: DLOBSubscriptionConfig) {
+		this.dlobSource = config.dlobSource;
+		this.slotSource = config.slotSource;
+		this.updateFrequency = config.updateFrequency;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		await this.updateDLOB();
+
+		this.intervalId = setInterval(async () => {
+			try {
+				await this.updateDLOB();
+				this.eventEmitter.emit('update', this.dlob);
+			} catch (e) {
+				this.eventEmitter.emit('error', e);
+			}
+		}, this.updateFrequency);
+	}
+
+	async updateDLOB(): Promise<void> {
+		this.dlob = await this.dlobSource.getDLOB(this.slotSource.getSlot());
+	}
+
+	public getDLOB(): DLOB {
+		return this.dlob;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/dlob/types.ts

@@ -0,0 +1,20 @@
+import { DLOB } from './DLOB';
+
+export type DLOBSubscriptionConfig = {
+	dlobSource: DLOBSource;
+	slotSource: SlotSource;
+	updateFrequency: number;
+};
+
+export interface DLOBSubscriberEvents {
+	update: (dlob: DLOB) => void;
+	error: (e: Error) => void;
+}
+
+export interface DLOBSource {
+	getDLOB(slot: number): Promise<DLOB>;
+}
+
+export interface SlotSource {
+	getSlot(): number;
+}