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

package/src/slot/SlotSubscriber.ts

@@ -3,7 +3,9 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
-type SlotSubscriberConfig = {}; // for future customization
+type SlotSubscriberConfig = {
+	resubTimeoutMs?: number;
+}; // for future customization
 
 export interface SlotSubscriberEvents {
 	newSlot: (newSlot: number) => void;
@@ -14,15 +16,22 @@ export class SlotSubscriber {
 	subscriptionId: number;
 	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
 
+	// Reconnection
+	timeoutId?: NodeJS.Timeout;
+	resubTimeoutMs?: number;
+	isUnsubscribing = false;
+	receivingData = false;
+
 	public constructor(
 		private connection: Connection,
-		_config?: SlotSubscriberConfig
+		config?: SlotSubscriberConfig
 	) {
 		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = config?.resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<void> {
-		if (this.subscriptionId) {
+		if (this.subscriptionId != null) {
 			return;
 		}
 
@@ -30,19 +39,57 @@ export class SlotSubscriber {
 
 		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
 			if (!this.currentSlot || this.currentSlot < slotInfo.slot) {
+				if (this.resubTimeoutMs && !this.isUnsubscribing) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+				}
 				this.currentSlot = slotInfo.slot;
 				this.eventEmitter.emit('newSlot', slotInfo.slot);
 			}
 		});
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(
+					`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`
+				);
+				await this.unsubscribe(true);
+				this.receivingData = false;
+				await this.subscribe();
+			}
+		}, this.resubTimeoutMs);
 	}
 
 	public getSlot(): number {
 		return this.currentSlot;
 	}
 
-	public async unsubscribe(): Promise<void> {
-		if (this.subscriptionId) {
+	public async unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		if (this.subscriptionId != null) {
 			await this.connection.removeSlotChangeListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+			this.isUnsubscribing = false;
+		} else {
+			this.isUnsubscribing = false;
 		}
 	}
 }

package/src/types.ts

@@ -182,6 +182,7 @@ export class SpotFulfillmentStatus {
 export class DepositExplanation {
 	static readonly NONE = { none: {} };
 	static readonly TRANSFER = { transfer: {} };
+	static readonly BORROW = { borrow: {} };
 }
 
 export class SettlePnlExplanation {
@@ -710,7 +711,7 @@ export type AMM = {
 	pegMultiplier: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
-	last24hAvgFundingRate: BN;
+	last24HAvgFundingRate: BN;
 	lastFundingRateShort: BN;
 	lastFundingRateLong: BN;
 

package/src/user.ts

@@ -27,6 +27,7 @@ import {
 	OPEN_ORDER_MARGIN_REQUIREMENT,
 	PRICE_PRECISION,
 	QUOTE_PRECISION,
+	QUOTE_PRECISION_EXP,
 	QUOTE_SPOT_MARKET_INDEX,
 	SPOT_MARKET_WEIGHT_PRECISION,
 	TEN,
@@ -40,6 +41,7 @@ import {
 	UserAccountSubscriber,
 } from './accounts/types';
 import {
+	BigNum,
 	BN,
 	calculateBaseAssetValue,
 	calculateMarketMarginRatio,
@@ -1399,8 +1401,12 @@ export class User {
 		includeOpenOrders = false
 	): BN {
 		const userPosition =
-			this.getPerpPositionWithLPSettle(marketIndex)[0] ||
-			this.getEmptyPosition(marketIndex);
+			this.getPerpPositionWithLPSettle(
+				marketIndex,
+				undefined,
+				false,
+				true
+			)[0] || this.getEmptyPosition(marketIndex);
 		const market = this.driftClient.getPerpMarketAccount(
 			userPosition.marketIndex
 		);
@@ -3013,7 +3019,7 @@ export class User {
 		let makerFee =
 			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
 
-		if (marketIndex && isVariant(marketType, 'perp')) {
+		if (marketIndex !== undefined && isVariant(marketType, 'perp')) {
 			const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
 			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
 			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
@@ -3030,11 +3036,22 @@ export class User {
 	 * @param quoteAmount
 	 * @returns feeForQuote : Precision QUOTE_PRECISION
 	 */
-	public calculateFeeForQuoteAmount(quoteAmount: BN): BN {
-		const feeTier = this.getUserFeeTier(MarketType.PERP);
-		return quoteAmount
-			.mul(new BN(feeTier.feeNumerator))
-			.div(new BN(feeTier.feeDenominator));
+	public calculateFeeForQuoteAmount(quoteAmount: BN, marketIndex?: number): BN {
+		if (marketIndex !== undefined) {
+			const takerFeeMultiplier = this.getMarketFees(
+				MarketType.PERP,
+				marketIndex
+			).takerFee;
+			const feeAmountNum =
+				BigNum.from(quoteAmount, QUOTE_PRECISION_EXP).toNum() *
+				takerFeeMultiplier;
+			return BigNum.fromPrint(feeAmountNum.toString(), QUOTE_PRECISION_EXP).val;
+		} else {
+			const feeTier = this.getUserFeeTier(MarketType.PERP);
+			return quoteAmount
+				.mul(new BN(feeTier.feeNumerator))
+				.div(new BN(feeTier.feeDenominator));
+		}
 	}
 
 	/**

package/src/userMap/userMap.ts

@@ -60,6 +60,7 @@ export class UserMap implements UserMapInterface {
 		}
 	};
 	private decode;
+	private mostRecentSlot = 0;
 
 	private syncPromise?: Promise<void>;
 	private syncPromiseResolver: () => void;
@@ -312,6 +313,8 @@ export class UserMap implements UserMapInterface {
 
 			const slot = rpcResponseAndContext.context.slot;
 
+			this.updateLatestSlot(slot);
+
 			const programAccountBufferMap = new Map<string, Buffer>();
 			for (const programAccount of rpcResponseAndContext.value) {
 				programAccountBufferMap.set(
@@ -373,6 +376,7 @@ export class UserMap implements UserMapInterface {
 		userAccount: UserAccount,
 		slot: number
 	) {
+		this.updateLatestSlot(slot);
 		if (!this.userMap.has(key)) {
 			this.addPubkey(new PublicKey(key), userAccount, slot);
 		} else {
@@ -380,4 +384,12 @@ export class UserMap implements UserMapInterface {
 			user.accountSubscriber.updateData(userAccount, slot);
 		}
 	}
+
+	updateLatestSlot(slot: number): void {
+		this.mostRecentSlot = Math.max(slot, this.mostRecentSlot);
+	}
+
+	public getSlot(): number {
+		return this.mostRecentSlot;
+	}
 }

package/tests/amm/test.ts

@@ -4,6 +4,8 @@ import {
 	PRICE_PRECISION,
 	AMM_RESERVE_PRECISION,
 	QUOTE_PRECISION,
+	PERCENTAGE_PRECISION,
+	calculateSpread,
 	calculateSpreadBN,
 	ZERO,
 	ONE,
@@ -19,6 +21,12 @@ import {
 	L2Level,
 	calculateUpdatedAMM,
 	calculateMarketOpenBidAsk,
+	calculateSpreadReserves,
+	calculatePrice,
+	BID_ASK_SPREAD_PRECISION,
+	squareRootBN,
+	calculateReferencePriceOffset,
+	calculateInventoryLiquidityRatio,
 } from '../../src';
 import { mockPerpMarkets } from '../dlob/helpers';
 
@@ -293,7 +301,7 @@ describe('AMM Tests', () => {
 			volume24H,
 			true
 		);
-		console.log(terms1);
+		// console.log(terms1);
 
 		console.log('long/short spread:', l1, s1);
 		assert(l1 == 14864);
@@ -326,11 +334,77 @@ describe('AMM Tests', () => {
 			true
 		);
 
-		console.log(terms2);
+		// console.log(terms2);
 		assert(terms2.effectiveLeverageCapped >= 1.0002);
 		assert(terms2.inventorySpreadScale == 1.73492);
 		assert(terms2.longSpread == 4262);
 		assert(terms2.shortSpread == 43238);
+
+		// add spread offset
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		const terms3: AMMSpreadTerms = calculateSpreadBN(
+			300,
+			new BN(0),
+			new BN(484),
+			47500,
+			new BN(923807816209694),
+			new BN(925117623772584),
+			new BN(13731157),
+			new BN(-1314027016625),
+			new BN(13667686),
+			new BN(115876379475),
+			new BN(91316628),
+			new BN(928097825691666),
+			new BN(907979542352912),
+			new BN(945977491145601),
+			new BN(161188),
+			new BN(1459632439),
+			new BN(12358265776),
+			new BN(72230366233),
+			new BN(432067603632),
+			true
+		);
+
+		console.log(terms3);
+		assert(terms3.effectiveLeverageCapped >= 1.0002);
+		assert(terms3.inventorySpreadScale == 1.73492);
+		assert(terms3.longSpread == 4262);
+		assert(terms3.shortSpread == 43238);
+		assert(terms3.longSpread + terms3.shortSpread == 47500);
+
+		// add spread offset
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-ignore
+		const terms4: AMMSpreadTerms = calculateSpreadBN(
+			300,
+			new BN(0),
+			new BN(484),
+			47500,
+			new BN(923807816209694),
+			new BN(925117623772584),
+			new BN(13731157),
+			new BN(-1314027016625),
+			new BN(13667686),
+			new BN(115876379475),
+			new BN(91316628),
+			new BN(928097825691666),
+			new BN(907979542352912),
+			new BN(945977491145601),
+			new BN(161188),
+			new BN(1459632439),
+			new BN(12358265776),
+			new BN(72230366233),
+			new BN(432067603632),
+			true
+		);
+
+		console.log(terms4);
+		assert(terms4.effectiveLeverageCapped >= 1.0002);
+		assert(terms4.inventorySpreadScale == 1.73492);
+		assert(terms4.longSpread == 4262);
+		assert(terms4.shortSpread == 43238);
+		assert(terms4.longSpread + terms4.shortSpread == 47500);
 	});
 
 	it('Corner Case Spreads', () => {
@@ -361,16 +435,150 @@ describe('AMM Tests', () => {
 
 		console.log(terms2);
 		assert(terms2.effectiveLeverageCapped <= 1.000001);
-		assert(
-			terms2.inventorySpreadScale == 1.013527,
-			`got: ${terms2.inventorySpreadScale}`
+		assert(terms2.inventorySpreadScale == 1.0306);
+		assert(terms2.longSpread == 515);
+		assert(terms2.shortSpread == 5668);
+	});
+
+	it('Spread Reserves (with offset)', () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+		const mockAmm = mockMarket1.amm;
+		const now = new BN(new Date().getTime() / 1000); //todo
+
+		const oraclePriceData = {
+			price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+			slot: new BN(68 + 1),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+
+		const reserves = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		assert(reserves[0].baseAssetReserve.eq(new BN('1000000000')));
+		assert(reserves[0].quoteAssetReserve.eq(new BN('12000000000')));
+		assert(reserves[1].baseAssetReserve.eq(new BN('1000000000')));
+		assert(reserves[1].quoteAssetReserve.eq(new BN('12000000000')));
+
+		mockAmm.baseAssetReserve = new BN(1000000000);
+		mockAmm.quoteAssetReserve = new BN(1000000000);
+		mockAmm.sqrtK = new BN(1000000000);
+
+		mockAmm.baseAssetAmountWithAmm = new BN(0);
+		mockAmm.pegMultiplier = new BN(13.553 * PEG_PRECISION.toNumber());
+		mockAmm.ammJitIntensity = 100;
+		mockAmm.curveUpdateIntensity = 200;
+		mockAmm.baseSpread = 2500;
+		mockAmm.maxSpread = 25000;
+
+		mockAmm.last24HAvgFundingRate = new BN(7590328523);
+
+		mockAmm.lastMarkPriceTwap = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 - 0.01) * 1e6
+		);
+		mockAmm.historicalOracleData.lastOraclePriceTwap = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 + 0.015) * 1e6
 		);
-		assert(terms2.longSpread == 1146);
-		assert(terms2.shortSpread == 6686);
+
+		mockAmm.historicalOracleData.lastOraclePriceTwap5Min = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 + 0.005) * 1e6
+		);
+		mockAmm.lastMarkPriceTwap5Min = new BN(
+			(oraclePriceData.price.toNumber() / 1e6 - 0.005) * 1e6
+		);
+
+		console.log('starting rr:');
+		let reservePrice = undefined;
+		if (!reservePrice) {
+			reservePrice = calculatePrice(
+				mockAmm.baseAssetReserve,
+				mockAmm.quoteAssetReserve,
+				mockAmm.pegMultiplier
+			);
+		}
+
+		const targetPrice = oraclePriceData?.price || reservePrice;
+		const confInterval = oraclePriceData.confidence || ZERO;
+		const targetMarkSpreadPct = reservePrice
+			.sub(targetPrice)
+			.mul(BID_ASK_SPREAD_PRECISION)
+			.div(reservePrice);
+
+		const confIntervalPct = confInterval
+			.mul(BID_ASK_SPREAD_PRECISION)
+			.div(reservePrice);
+
+		// now = now || new BN(new Date().getTime() / 1000); //todo
+		const liveOracleStd = calculateLiveOracleStd(mockAmm, oraclePriceData, now);
+		console.log('reservePrice:', reservePrice.toString());
+		console.log('targetMarkSpreadPct:', targetMarkSpreadPct.toString());
+		console.log('confIntervalPct:', confIntervalPct.toString());
+
+		console.log('liveOracleStd:', liveOracleStd.toString());
+
+		const tt = calculateSpread(mockAmm, oraclePriceData, now);
+		console.log(tt);
+
+		console.log('amm.baseAssetReserve:', mockAmm.baseAssetReserve.toString());
+		assert(mockAmm.baseAssetReserve.eq(new BN('1000000000')));
+		const reserves2 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves2[1].baseAssetReserve.toString());
+		console.log(reserves2[1].quoteAssetReserve.toString());
+
+		assert(reserves2[0].baseAssetReserve.eq(new BN('1006711408')));
+		assert(reserves2[0].quoteAssetReserve.eq(new BN('993333334')));
+		assert(reserves2[1].baseAssetReserve.eq(new BN('993377484')));
+		assert(reserves2[1].quoteAssetReserve.eq(new BN('1006666666')));
+
+		// create imbalance for reference price offset
+		mockAmm.baseAssetReserve = new BN(1000000000 * 1.1);
+		mockAmm.quoteAssetReserve = new BN(1000000000 / 1.1);
+		mockAmm.sqrtK = squareRootBN(
+			mockAmm.baseAssetReserve.mul(mockAmm.quoteAssetReserve)
+		);
+
+		mockAmm.baseAssetAmountWithAmm = new BN(-1000000000 * 0.1);
+
+		const maxOffset = Math.max(
+			mockAmm.maxSpread / 5,
+			PERCENTAGE_PRECISION.toNumber() / 1000
+		);
+		const liquidityFraction = calculateInventoryLiquidityRatio(
+			mockAmm.baseAssetAmountWithAmm,
+			mockAmm.baseAssetReserve,
+			mockAmm.minBaseAssetReserve,
+			mockAmm.maxBaseAssetReserve
+		);
+		console.log('liquidityFraction:', liquidityFraction.toString());
+		assert(liquidityFraction.eq(new BN(1000000))); // full
+
+		const referencePriceOffset = calculateReferencePriceOffset(
+			reservePrice,
+			mockAmm.last24HAvgFundingRate,
+			liquidityFraction,
+			mockAmm.historicalOracleData.lastOraclePriceTwap5Min,
+			mockAmm.lastMarkPriceTwap5Min,
+			mockAmm.historicalOracleData.lastOraclePriceTwap,
+			mockAmm.lastMarkPriceTwap,
+			maxOffset
+		);
+		console.log('referencePriceOffset:', referencePriceOffset.toString());
+		assert(referencePriceOffset.eq(new BN(5000)));
+		assert(referencePriceOffset.eq(new BN(maxOffset)));
+
+		const reserves3 = calculateSpreadReserves(mockAmm, oraclePriceData, now);
+		console.log(reserves3[1].baseAssetReserve.toString());
+		console.log(reserves3[1].quoteAssetReserve.toString());
+
+		assert(reserves3[0].baseAssetReserve.eq(new BN('1164705879')));
+		assert(reserves3[0].quoteAssetReserve.eq(new BN('858585859')));
+		assert(reserves3[1].baseAssetReserve.eq(new BN('1042105261')));
+		assert(reserves3[1].quoteAssetReserve.eq(new BN('959595959')));
 	});
 
 	it('live update functions', () => {
-		const mockAmm = mockPerpMarkets[0].amm;
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+		const mockAmm = mockMarket1.amm;
 		const now = new BN(new Date().getTime() / 1000); //todo
 
 		const oraclePriceData = {
@@ -469,8 +677,8 @@ describe('AMM Tests', () => {
 
 		assert(markTwapLive.eq(new BN('1949826')));
 		assert(oracleTwapLive.eq(new BN('1942510')));
-		assert(est1.eq(new BN('15692')), `got: ${est1}`);
-		assert(est2.eq(new BN('15692')));
+		assert(est1.eq(new BN('16525')));
+		assert(est2.eq(new BN('16525')));
 	});
 
 	it('predicted funding rate mock2', async () => {
@@ -559,7 +767,7 @@ describe('AMM Tests', () => {
 		assert(markTwapLive.eq(new BN('1222131')));
 		assert(oracleTwapLive.eq(new BN('1222586')));
 		assert(est1.eq(est2));
-		assert(est2.eq(new BN('-1550')), `got: ${est2}`);
+		assert(est2.eq(new BN('-719')));
 	});
 
 	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders, low liquidity)', async () => {

package/tests/bn/test.ts

@@ -147,6 +147,33 @@ describe('BigNum Tests', () => {
 			'-1.0000000000000'
 		);
 		expect(BigNum.from('-100', 6).print()).to.equal('-0.000100');
+
+		// Case 7: really large numbers + switching between scientific/financial
+		expect(BigNum.fromPrint('123000000000').toMillified(3)).to.equal('123B');
+		expect(
+			BigNum.fromPrint('123000000000').toMillified(3, undefined, 'scientific')
+		).to.equal('123G'); // (G = Giga)
+		expect(BigNum.fromPrint('123000000000000').toMillified(3)).to.equal('123T');
+		expect(
+			BigNum.fromPrint('123000000000000').toMillified(
+				3,
+				undefined,
+				'scientific'
+			)
+		).to.equal('123T'); // (T = Tera)
+		expect(BigNum.fromPrint('123000000000000000').toMillified(3)).to.equal(
+			'123Q'
+		);
+		expect(
+			BigNum.fromPrint('123000000000000000').toMillified(
+				3,
+				undefined,
+				'scientific'
+			)
+		).to.equal('123P'); // (P = Peta)
+
+		// TODO : Need to make the appropriate changes for the next line to pass
+		// expect(BigNum.fromPrint('123000000000000000000').toMillified(3)).to.equal('123000Q');
 	});
 
 	it('can initialise from string values correctly', () => {

package/tests/dlob/helpers.ts

@@ -84,7 +84,7 @@ export const mockAMM: AMM = {
 	baseAssetAmountWithUnsettledLp: new BN(0),
 	orderStepSize: new BN(0),
 	orderTickSize: new BN(1),
-	last24hAvgFundingRate: new BN(0),
+	last24HAvgFundingRate: new BN(0),
 	lastFundingRateShort: new BN(0),
 	lastFundingRateLong: new BN(0),
 	concentrationCoef: new BN(0),