@drift-labs/sdk 2.95.0-beta.9 → 2.96.0-beta.1

package/src/math/insurance.ts

@@ -1,5 +1,51 @@
-import { ZERO } from '../constants/numericConstants';
-import { BN } from '../index';
+import { PERCENTAGE_PRECISION, ZERO } from '../constants/numericConstants';
+import { BN, SpotMarketAccount, SpotBalanceType } from '../index';
+import { getTokenAmount } from '../math/spotBalance';
+
+export function nextRevenuePoolSettleApr(
+	spotMarket: SpotMarketAccount,
+	vaultBalance: BN, // vault token amount
+	amount?: BN // delta token amount
+): number {
+	const MAX_APR = new BN(10).mul(PERCENTAGE_PRECISION); // 1000% APR
+
+	// Conmputing the APR:
+	const revenuePoolBN = getTokenAmount(
+		spotMarket.revenuePool.scaledBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+
+	const payoutRatio = 0.1;
+	const ratioForStakers =
+		spotMarket.insuranceFund.totalFactor > 0 &&
+		spotMarket.insuranceFund.userFactor > 0 &&
+		spotMarket.insuranceFund.revenueSettlePeriod.gt(ZERO)
+			? spotMarket.insuranceFund.userFactor /
+			  spotMarket.insuranceFund.totalFactor
+			: 0;
+
+	// Settle periods from on-chain data:
+	const revSettlePeriod =
+		spotMarket.insuranceFund.revenueSettlePeriod.toNumber() * 1000;
+
+	const settlesPerYear = 31536000000 / revSettlePeriod;
+
+	const projectedAnnualRev = revenuePoolBN
+		.muln(settlesPerYear)
+		.muln(payoutRatio);
+
+	const uncappedApr = vaultBalance.add(amount).eq(ZERO)
+		? 0
+		: projectedAnnualRev.muln(1000).div(vaultBalance.add(amount)).toNumber() *
+		  100 *
+		  1000;
+	const cappedApr = Math.min(uncappedApr, MAX_APR.toNumber());
+
+	const nextApr = cappedApr * ratioForStakers;
+
+	return nextApr;
+}
 
 export function stakeAmountToShares(
 	amount: BN,

package/src/math/spotBalance.ts

@@ -379,9 +379,10 @@ export function calculateSpotMarketBorrowCapacity(
 
 export function calculateInterestRate(
 	bank: SpotMarketAccount,
-	delta = ZERO
+	delta = ZERO,
+	currentUtilization: BN = null
 ): BN {
-	const utilization = calculateUtilization(bank, delta);
+	const utilization = currentUtilization || calculateUtilization(bank, delta);
 	let interestRate: BN;
 	if (utilization.gt(new BN(bank.optimalUtilization))) {
 		const surplusUtilization = utilization.sub(new BN(bank.optimalUtilization));
@@ -414,13 +415,14 @@ export function calculateInterestRate(
 
 export function calculateDepositRate(
 	bank: SpotMarketAccount,
-	delta = ZERO
+	delta = ZERO,
+	currentUtilization: BN = null
 ): BN {
 	// positive delta => adding to deposit
 	// negative delta => adding to borrow
 
-	const utilization = calculateUtilization(bank, delta);
-	const borrowRate = calculateBorrowRate(bank, delta);
+	const utilization = currentUtilization || calculateUtilization(bank, delta);
+	const borrowRate = calculateBorrowRate(bank, delta, utilization);
 	const depositRate = borrowRate
 		.mul(PERCENTAGE_PRECISION.sub(new BN(bank.insuranceFund.totalFactor)))
 		.mul(utilization)
@@ -429,8 +431,12 @@ export function calculateDepositRate(
 	return depositRate;
 }
 
-export function calculateBorrowRate(bank: SpotMarketAccount, delta = ZERO): BN {
-	return calculateInterestRate(bank, delta);
+export function calculateBorrowRate(
+	bank: SpotMarketAccount,
+	delta = ZERO,
+	currentUtilization: BN = null
+): BN {
+	return calculateInterestRate(bank, delta, currentUtilization);
 }
 
 export function calculateInterestAccumulated(

package/src/orderSubscriber/OrderSubscriber.ts

@@ -11,11 +11,12 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { BN } from '../index';
 import { decodeUser } from '../decode/user';
+import { grpcSubscription } from './grpcSubscription';
 
 export class OrderSubscriber {
 	driftClient: DriftClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
-	subscription: PollingSubscription | WebsocketSubscription;
+	subscription: PollingSubscription | WebsocketSubscription | grpcSubscription;
 	commitment: Commitment;
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
@@ -34,6 +35,19 @@ export class OrderSubscriber {
 				orderSubscriber: this,
 				frequency: config.subscriptionConfig.frequency,
 			});
+		} else if (config.subscriptionConfig.type === 'grpc') {
+			this.subscription = new grpcSubscription({
+				grpcConfigs: config.subscriptionConfig.configs,
+				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,
+			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,

package/src/orderSubscriber/grpcSubscription.ts

@@ -0,0 +1,126 @@
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+import { OrderSubscriber } from './OrderSubscriber';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { UserAccount } from '../types';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+
+export class grpcSubscription {
+	private orderSubscriber: OrderSubscriber;
+	private commitment: Commitment;
+	private skipInitialLoad: boolean;
+	private resubOpts?: ResubOpts;
+	private resyncIntervalMs?: number;
+
+	private subscriber?: grpcProgramAccountSubscriber<UserAccount>;
+	private resyncTimeoutId?: NodeJS.Timeout;
+
+	private decoded?: boolean;
+
+	private grpcConfigs: GrpcConfigs;
+
+	constructor({
+		grpcConfigs,
+		orderSubscriber,
+		commitment,
+		skipInitialLoad = false,
+		resubOpts,
+		resyncIntervalMs,
+		decoded = true,
+	}: {
+		grpcConfigs: GrpcConfigs;
+		orderSubscriber: OrderSubscriber;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubOpts?: ResubOpts;
+		resyncIntervalMs?: number;
+		decoded?: boolean;
+	}) {
+		this.orderSubscriber = orderSubscriber;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubOpts = resubOpts;
+		this.resyncIntervalMs = resyncIntervalMs;
+		this.decoded = decoded;
+		this.grpcConfigs = grpcConfigs;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscriber) {
+			return;
+		}
+
+		this.subscriber = new grpcProgramAccountSubscriber<UserAccount>(
+			this.grpcConfigs,
+			'OrderSubscriber',
+			'User',
+			this.orderSubscriber.driftClient.program,
+			this.orderSubscriber.decodeFn,
+			{
+				filters: [getUserFilter(), getNonIdleUserFilter()],
+				commitment: this.commitment,
+			},
+			this.resubOpts
+		);
+
+		await this.subscriber.subscribe(
+			(
+				accountId: PublicKey,
+				account: UserAccount,
+				context: Context,
+				buffer: Buffer
+			) => {
+				const userKey = accountId.toBase58();
+				if (this.decoded ?? true) {
+					this.orderSubscriber.tryUpdateUserAccount(
+						userKey,
+						'decoded',
+						account,
+						context.slot
+					);
+				} else {
+					this.orderSubscriber.tryUpdateUserAccount(
+						userKey,
+						'buffer',
+						buffer,
+						context.slot
+					);
+				}
+			}
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.orderSubscriber.fetch();
+		}
+
+		if (this.resyncIntervalMs) {
+			const recursiveResync = () => {
+				this.resyncTimeoutId = setTimeout(() => {
+					this.orderSubscriber
+						.fetch()
+						.catch((e) => {
+							console.error('Failed to resync in OrderSubscriber');
+							console.log(e);
+						})
+						.finally(() => {
+							// eslint-disable-next-line @typescript-eslint/no-unused-vars
+							if (!this.resyncTimeoutId) return;
+							recursiveResync();
+						});
+				}, this.resyncIntervalMs);
+			};
+			recursiveResync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+		if (this.resyncTimeoutId !== undefined) {
+			clearTimeout(this.resyncTimeoutId);
+			this.resyncTimeoutId = undefined;
+		}
+	}
+}

package/src/orderSubscriber/types.ts

@@ -1,6 +1,7 @@
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { Order, UserAccount } from '../types';
 import { DriftClient } from '../driftClient';
+import { GrpcConfigs } from '../accounts/types';
 
 export type OrderSubscriberConfig = {
 	driftClient: DriftClient;
@@ -10,6 +11,15 @@ export type OrderSubscriberConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
+		| {
+				type: 'grpc';
+				skipInitialLoad?: boolean;
+				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
+				resyncIntervalMs?: number;
+				configs: GrpcConfigs;
+				commitment?: Commitment;
+		  }
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;

package/src/user.ts

@@ -98,6 +98,7 @@ import {
 	calculatePerpFuelBonus,
 	calculateInsuranceFuelBonus,
 } from './math/fuel';
+import { grpcUserAccountSubscriber } from './accounts/grpcUserAccountSubscriber';
 
 export class User {
 	driftClient: DriftClient;
@@ -128,6 +129,16 @@ export class User {
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
+		} else if (config.accountSubscription?.type === 'grpc') {
+			this.accountSubscriber = new grpcUserAccountSubscriber(
+				config.accountSubscription.configs,
+				config.driftClient.program,
+				config.userAccountPublicKey,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				}
+			);
 		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,

package/src/userConfig.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-import { UserAccountSubscriber } from './accounts/types';
+import { GrpcConfigs, UserAccountSubscriber } from './accounts/types';
 
 export type UserConfig = {
 	accountSubscription?: UserSubscriptionConfig;
@@ -23,4 +23,10 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'custom';
 			userAccountSubscriber: UserAccountSubscriber;
+	  }
+	| {
+			type: 'grpc';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			configs: GrpcConfigs;
 	  };

package/src/userMap/grpcSubscription.ts

@@ -0,0 +1,83 @@
+import { UserMap } from './userMap';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
+import { UserAccount } from '../types';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+
+export class grpcSubscription {
+	private configs: GrpcConfigs;
+	private userMap: UserMap;
+	private commitment: Commitment;
+	private skipInitialLoad: boolean;
+	private resubOpts?: ResubOpts;
+	private includeIdle?: boolean;
+	private decodeFn: (name: string, data: Buffer) => UserAccount;
+
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
+
+	constructor({
+		configs,
+		userMap,
+		commitment,
+		skipInitialLoad = false,
+		resubOpts,
+		includeIdle = false,
+		decodeFn,
+	}: {
+		configs: GrpcConfigs;
+		userMap: UserMap;
+		commitment: Commitment;
+		skipInitialLoad?: boolean;
+		resubOpts?: ResubOpts;
+		includeIdle?: boolean;
+		decodeFn: (name: string, data: Buffer) => UserAccount;
+	}) {
+		this.userMap = userMap;
+		this.commitment = commitment;
+		this.skipInitialLoad = skipInitialLoad;
+		this.resubOpts = resubOpts;
+		this.includeIdle = includeIdle || false;
+		this.decodeFn = decodeFn;
+		this.configs = configs;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (!this.subscriber) {
+			const filters = [getUserFilter()];
+			if (!this.includeIdle) {
+				filters.push(getNonIdleUserFilter());
+			}
+			this.subscriber = new grpcProgramAccountSubscriber<UserAccount>(
+				this.configs,
+				'UserMap',
+				'User',
+				this.userMap.driftClient.program,
+				this.decodeFn,
+				{
+					filters,
+					commitment: this.commitment,
+				},
+				this.resubOpts
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, account: UserAccount, context: Context) => {
+				const userKey = accountId.toBase58();
+				this.userMap.updateUserAccount(userKey, account, context.slot);
+			}
+		);
+
+		if (!this.skipInitialLoad) {
+			await this.userMap.sync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+	}
+}

package/src/userMap/userMap.ts

@@ -36,6 +36,7 @@ import {
 import { WebsocketSubscription } from './WebsocketSubscription';
 import { PollingSubscription } from './PollingSubscription';
 import { decodeUser } from '../decode/user';
+import { grpcSubscription } from './grpcSubscription';
 
 const MAX_USER_ACCOUNT_SIZE_BYTES = 4376;
 
@@ -75,7 +76,10 @@ export class UserMap implements UserMapInterface {
 	private includeIdle: boolean;
 	private disableSyncOnTotalAccountsChange: boolean;
 	private lastNumberOfSubAccounts: BN;
-	private subscription: PollingSubscription | WebsocketSubscription;
+	private subscription:
+		| PollingSubscription
+		| WebsocketSubscription
+		| grpcSubscription;
 	private stateAccountUpdateCallback = async (state: StateAccount) => {
 		if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
 			await this.sync();
@@ -122,6 +126,18 @@ export class UserMap implements UserMapInterface {
 				frequency: config.subscriptionConfig.frequency,
 				skipInitialLoad: config.skipInitialLoad,
 			});
+		} else if (config.subscriptionConfig.type === 'grpc') {
+			this.subscription = new grpcSubscription({
+				configs: config.subscriptionConfig.configs,
+				userMap: this,
+				commitment: this.commitment,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig.logResubMessages,
+				},
+				skipInitialLoad: config.skipInitialLoad,
+				decodeFn,
+			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				userMap: this,

package/src/userMap/userMapConfig.ts

@@ -1,5 +1,6 @@
 import { Commitment, Connection } from '@solana/web3.js';
 import { DriftClient } from '../driftClient';
+import { GrpcConfigs } from '../accounts/types';
 
 // passed into UserMap.getUniqueAuthorities to filter users
 export type UserAccountFilterCriteria = {
@@ -27,6 +28,13 @@ export type UserMapConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
+		| {
+				type: 'grpc';
+				configs: GrpcConfigs;
+				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
+				commitment?: Commitment;
+		  }
 		| {
 				type: 'websocket';
 				resubTimeoutMs?: number;

package/src/userStatsConfig.ts

@@ -1,6 +1,7 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { GrpcConfigs } from './accounts/types';
 
 export type UserStatsConfig = {
 	accountSubscription?: UserStatsSubscriptionConfig;
@@ -21,4 +22,10 @@ export type UserStatsSubscriptionConfig =
 	  }
 	| {
 			type: 'custom';
+	  }
+	| {
+			type: 'grpc';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			configs: GrpcConfigs;
 	  };