@drift-labs/sdk 2.18.0 → 2.19.1

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.18.0",
+  "version": "2.19.1",
   "name": "drift",
   "instructions": [
     {
@@ -6237,14 +6237,17 @@
           {
             "name": "Pyth"
           },
-          {
-            "name": "Pyth1000"
-          },
           {
             "name": "Switchboard"
           },
           {
             "name": "QuoteAsset"
+          },
+          {
+            "name": "Pyth1K"
+          },
+          {
+            "name": "Pyth1M"
           }
         ]
       }

package/src/math/amm.ts

@@ -11,7 +11,6 @@ import {
 	MARGIN_PRECISION,
 	PRICE_DIV_PEG,
 	PERCENTAGE_PRECISION,
-	BASE_PRECISION,
 	DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT,
 	TWO,
 } from '../constants/numericConstants';
@@ -362,10 +361,12 @@ export function calculateInventoryScale(
 	maxSpread: number
 ): number {
 	if (baseAssetAmountWithAmm.eq(ZERO)) {
-		return 0;
+		return 1;
 	}
 
-	const defaultLargeBidAskFactor = BID_ASK_SPREAD_PRECISION.mul(new BN(10));
+	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = BID_ASK_SPREAD_PRECISION.mul(
+		new BN(10)
+	);
 	// inventory skew
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
 		baseAssetReserve,
@@ -373,34 +374,32 @@ export function calculateInventoryScale(
 		maxBaseAssetReserve
 	);
 
-	const minSideLiquidity = BN.max(
-		new BN(1),
-		BN.min(openBids.abs(), openAsks.abs())
+	const minSideLiquidity = BN.min(openBids.abs(), openAsks.abs());
+
+	const inventoryScaleBN = BN.min(
+		baseAssetAmountWithAmm
+			.mul(PERCENTAGE_PRECISION)
+			.div(BN.max(minSideLiquidity, ONE))
+			.abs(),
+		PERCENTAGE_PRECISION
 	);
 
 	const inventoryScaleMaxBN = BN.max(
-		defaultLargeBidAskFactor,
-		new BN(maxSpread / 2)
+		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+		new BN(maxSpread)
 			.mul(BID_ASK_SPREAD_PRECISION)
 			.div(new BN(Math.max(directionalSpread, 1)))
 	);
 
-	const inventoryScaleBN = baseAssetAmountWithAmm
-		.mul(BN.max(baseAssetAmountWithAmm.abs(), BASE_PRECISION))
-		.div(BASE_PRECISION)
-		.mul(defaultLargeBidAskFactor)
-		.div(minSideLiquidity)
-		.abs();
-
-	const inventoryScale =
-		BN.min(inventoryScaleMaxBN, inventoryScaleBN).toNumber() /
-		BID_ASK_SPREAD_PRECISION.toNumber();
-
-	const inventoryScaleMax =
-		inventoryScaleMaxBN.toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
-	const inventorySpreadScale = Math.min(inventoryScaleMax, 1 + inventoryScale);
+	const inventoryScaleCapped =
+		BN.min(
+			inventoryScaleMaxBN,
+			BID_ASK_SPREAD_PRECISION.add(
+				inventoryScaleMaxBN.mul(inventoryScaleBN).div(PERCENTAGE_PRECISION)
+			)
+		).toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
 
-	return inventorySpreadScale;
+	return inventoryScaleCapped;
 }
 
 export function calculateEffectiveLeverage(

package/src/math/trade.ts

@@ -782,7 +782,7 @@ export function calculateEstimatedSpotEntryPrice(
 				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
 				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
 
-				worstPrice = dlobLimitOrder;
+				worstPrice = dlobLimitOrderPrice;
 
 				dlobLimitOrder = dlobLimitOrders.next().value;
 			} else {

package/src/serum/serumSubscriber.ts

@@ -9,26 +9,32 @@ export class SerumSubscriber {
 	connection: Connection;
 	programId: PublicKey;
 	marketAddress: PublicKey;
-	accountLoader: BulkAccountLoader;
+	subscriptionType: 'polling' | 'websocket';
+	accountLoader: BulkAccountLoader | undefined;
 	market: Market;
 
 	subscribed: boolean;
 
 	asksAddress: PublicKey;
 	asks: Orderbook;
-	asksCallbackId: string;
+	asksCallbackId: string | number;
 	lastAsksSlot: number;
 
 	bidsAddress: PublicKey;
 	bids: Orderbook;
-	bidsCallbackId: string;
+	bidsCallbackId: string | number;
 	lastBidsSlot: number;
 
 	public constructor(config: SerumMarketSubscriberConfig) {
 		this.connection = config.connection;
 		this.programId = config.programId;
 		this.marketAddress = config.marketAddress;
-		this.accountLoader = config.accountSubscription.accountLoader;
+		if (config.accountSubscription.type === 'polling') {
+			this.subscriptionType = 'polling';
+			this.accountLoader = config.accountSubscription.accountLoader;
+		} else {
+			this.subscriptionType = 'websocket';
+		}
 	}
 
 	public async subscribe(): Promise<void> {
@@ -46,24 +52,44 @@ export class SerumSubscriber {
 		this.asksAddress = this.market.asksAddress;
 		this.asks = await this.market.loadAsks(this.connection);
 
-		this.asksCallbackId = await this.accountLoader.addAccount(
-			this.asksAddress,
-			(buffer, slot) => {
-				this.lastAsksSlot = slot;
-				this.asks = Orderbook.decode(this.market, buffer);
-			}
-		);
+		if (this.subscriptionType === 'websocket') {
+			this.asksCallbackId = this.connection.onAccountChange(
+				this.asksAddress,
+				(accountInfo, ctx) => {
+					this.lastAsksSlot = ctx.slot;
+					this.asks = Orderbook.decode(this.market, accountInfo.data);
+				}
+			);
+		} else {
+			this.asksCallbackId = await this.accountLoader.addAccount(
+				this.asksAddress,
+				(buffer, slot) => {
+					this.lastAsksSlot = slot;
+					this.asks = Orderbook.decode(this.market, buffer);
+				}
+			);
+		}
 
 		this.bidsAddress = this.market.bidsAddress;
 		this.bids = await this.market.loadBids(this.connection);
 
-		this.bidsCallbackId = await this.accountLoader.addAccount(
-			this.bidsAddress,
-			(buffer, slot) => {
-				this.lastBidsSlot = slot;
-				this.bids = Orderbook.decode(this.market, buffer);
-			}
-		);
+		if (this.subscriptionType === 'websocket') {
+			this.bidsCallbackId = this.connection.onAccountChange(
+				this.bidsAddress,
+				(accountInfo, ctx) => {
+					this.lastBidsSlot = ctx.slot;
+					this.bids = Orderbook.decode(this.market, accountInfo.data);
+				}
+			);
+		} else {
+			this.bidsCallbackId = await this.accountLoader.addAccount(
+				this.bidsAddress,
+				(buffer, slot) => {
+					this.lastBidsSlot = slot;
+					this.bids = Orderbook.decode(this.market, buffer);
+				}
+			);
+		}
 
 		this.subscribed = true;
 	}
@@ -91,8 +117,24 @@ export class SerumSubscriber {
 			return;
 		}
 
-		this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
-		this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+		// remove listeners
+		if (this.subscriptionType === 'websocket') {
+			await this.connection.removeAccountChangeListener(
+				this.asksCallbackId as number
+			);
+			await this.connection.removeAccountChangeListener(
+				this.bidsCallbackId as number
+			);
+		} else {
+			this.accountLoader.removeAccount(
+				this.asksAddress,
+				this.asksCallbackId as string
+			);
+			this.accountLoader.removeAccount(
+				this.bidsAddress,
+				this.bidsCallbackId as string
+			);
+		}
 
 		this.subscribed = false;
 	}

package/src/serum/types.ts

@@ -5,9 +5,13 @@ export type SerumMarketSubscriberConfig = {
 	connection: Connection;
 	programId: PublicKey;
 	marketAddress: PublicKey;
-	accountSubscription: {
-		// enables use to add web sockets in the future
-		type: 'polling';
-		accountLoader: BulkAccountLoader;
-	};
+	accountSubscription:
+		| {
+				// enables use to add web sockets in the future
+				type: 'polling';
+				accountLoader: BulkAccountLoader;
+		  }
+		| {
+				type: 'websocket';
+		  };
 };

package/src/types.ts

@@ -76,7 +76,8 @@ export class DepositDirection {
 
 export class OracleSource {
 	static readonly PYTH = { pyth: {} };
-	static readonly PYTH_1000 = { pyth1000: {} };
+	static readonly PYTH_1K = { pyth1K: {} };
+	static readonly PYTH_1M = { pyth1M: {} };
 	// static readonly SWITCHBOARD = { switchboard: {} };
 	static readonly QUOTE_ASSET = { quoteAsset: {} };
 }

package/tests/amm/test.ts

@@ -6,8 +6,10 @@ import {
 	QUOTE_PRECISION,
 	calculateSpreadBN,
 	ZERO,
+	ONE,
 	calculateLiveOracleStd,
 	calculateLiveOracleTwap,
+	calculateInventoryScale,
 } from '../../src';
 import { mockPerpMarkets } from '../dlob/helpers';
 
@@ -36,6 +38,176 @@ class AMMSpreadTerms {
 }
 
 describe('AMM Tests', () => {
+	it('Spread Maths', () => {
+		let iscale = calculateInventoryScale(
+			ZERO,
+			AMM_RESERVE_PRECISION,
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		assert(iscale == 1);
+
+		iscale = calculateInventoryScale(
+			ONE,
+			AMM_RESERVE_PRECISION,
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		assert(iscale == 1);
+
+		let baa = new BN(1000); 
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		console.log(iscale);
+		assert(iscale == 1.00024);
+
+		baa = new BN(100000); 
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		console.log(iscale);
+		assert(iscale == 1.024);
+
+		baa = new BN(1000000); 
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		console.log(iscale);
+		assert(iscale == 1.24048);
+
+		baa = new BN(10000000); // 2%
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		console.log(iscale);
+		assert(iscale == 3.44896);
+
+		baa = new BN(50000000); // 10%
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		console.log(iscale);
+		assert(iscale == 14.33332);
+
+
+		baa = AMM_RESERVE_PRECISION.div(new BN(4)); // 50%
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		console.log(iscale);
+		assert(iscale == 120); //100%
+
+		baa = AMM_RESERVE_PRECISION.div(new BN(4)); // 50%
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000 * 2,
+		);
+		console.log(iscale);
+		assert(iscale == 120 * 2); //100%
+
+		baa = AMM_RESERVE_PRECISION.div(new BN(5)); // <50%
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000 * 2,
+		);
+		assert(iscale == 160.99984); 
+
+		baa = new BN(855329058); 
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION,
+			250,
+			30000,
+		); // >100%
+		assert(iscale == 120);
+		assert(250*iscale == 30000);
+
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa), // ~85%
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		assert(iscale == 120);
+		assert(250*iscale == 30000);
+
+		baa = new BN(-855329058); // ~85%
+		iscale = calculateInventoryScale(
+			baa,
+			AMM_RESERVE_PRECISION.add(baa),
+			AMM_RESERVE_PRECISION.div(new BN(2)),
+			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
+			250,
+			30000,
+		);
+		assert(iscale == 120);
+		assert(250*iscale == 30000);
+
+		// 'bonk' scale
+		iscale = calculateInventoryScale(
+			new BN('30228000000000000'),
+			new BN('2496788386034912600'),
+			new BN('2443167585342470000'),
+			new BN('2545411471321696000'),
+			3500,
+			100000,
+		);
+		console.log(iscale);
+		console.log(3500*iscale/1e6);
+		assert(iscale == 18.762285);
+		assert(3500*iscale/1e6 == 0.06566799749999999); //6.5%
+
+
+
+	});
+
 	it('Various Spreads', () => {
 		const baseSpread: number = 0.025 * 1e6;
 		const lastOracleReservePriceSpreadPct: BN = ZERO;
@@ -150,9 +322,9 @@ describe('AMM Tests', () => {
 
 		console.log(terms2);
 		assert(terms2.effectiveLeverageCapped >= 1.0002);
-		assert(terms2.inventorySpreadScale == 10);
-		assert(terms2.longSpread == 798);
-		assert(terms2.shortSpread == 46702);
+		assert(terms2.inventorySpreadScale == 1.73492);
+		assert(terms2.longSpread == 4262);
+		assert(terms2.shortSpread == 43238);
 	});
 
 	it('Corner Case Spreads', () => {
@@ -183,8 +355,8 @@ describe('AMM Tests', () => {
 
 		console.log(terms2);
 		assert(terms2.effectiveLeverageCapped <= 1.000001);
-		assert(terms2.inventorySpreadScale == 1.117371);
-		assert(terms2.longSpread == 1263);
+		assert(terms2.inventorySpreadScale == 1.013527);
+		assert(terms2.longSpread == 1146);
 		assert(terms2.shortSpread == 6686);
 	});
 

package/tests/dlob/test.ts

@@ -5207,7 +5207,8 @@ describe('DLOB Spot Tests', () => {
 		expect(nodesToFillAfter[1].makerNode?.order?.orderId).to.equal(3);
 	});
 
-	it('Test limit orders skipping more recent post onlys', () => {
+	// add back if dlob checks limit order age again
+	it.skip('Test limit orders skipping more recent post onlys', () => {
 		const vAsk = new BN(15);
 		const vBid = new BN(8);