@drift-labs/sdk 2.18.0 → 2.19.0

package/lib/constants/perpMarkets.js

@@ -47,12 +47,12 @@ exports.DevnetPerpMarkets = [
     {
         fullName: 'Bonk',
         category: ['Meme'],
-        symbol: 'BONK-PERP',
-        baseAssetSymbol: 'BONK',
+        symbol: '1MBONK-PERP',
+        baseAssetSymbol: '1MBONK',
         marketIndex: 4,
         oracle: new web3_js_1.PublicKey('6bquU99ktV1VRiHDr8gMhDFt3kMfhCQo5nfNrg2Urvsn'),
         launchTs: 1677068931000,
-        oracleSource: __1.OracleSource.PYTH_1000,
+        oracleSource: __1.OracleSource.PYTH_1M,
     },
 ];
 exports.MainnetPerpMarkets = [
@@ -96,6 +96,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1675802661000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'Bonk',
+        category: ['Meme'],
+        symbol: '1MBONK-PERP',
+        baseAssetSymbol: '1MBONK',
+        marketIndex: 4,
+        oracle: new web3_js_1.PublicKey('8ihFLu5FimgTQ1Unh4dVyEHUGodJ5gJQCrQf4KUVB9bN'),
+        launchTs: 1677690149000,
+        oracleSource: __1.OracleSource.PYTH_1M,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/dlob/DLOB.js

@@ -286,8 +286,9 @@ class DLOB {
         }
     }
     getOrder(orderId, userAccount) {
+        const orderSignature = NodeList_1.getOrderSignature(orderId, userAccount);
         for (const nodeList of this.getNodeLists()) {
-            const node = nodeList.get(orderId, userAccount);
+            const node = nodeList.get(orderSignature);
             if (node) {
                 return node.order;
             }
@@ -761,20 +762,32 @@ class DLOB {
     determineMakerAndTaker(askNode, bidNode) {
         const askSlot = askNode.order.slot.add(new __1.BN(askNode.order.auctionDuration));
         const bidSlot = bidNode.order.slot.add(new __1.BN(bidNode.order.auctionDuration));
-        if (askSlot.lte(bidSlot) && !bidNode.order.postOnly) {
+        if (bidNode.order.postOnly && askNode.order.postOnly) {
+            return undefined;
+        }
+        else if (bidNode.order.postOnly) {
+            return {
+                takerNode: askNode,
+                makerNode: bidNode,
+            };
+        }
+        else if (askNode.order.postOnly) {
             return {
                 takerNode: bidNode,
                 makerNode: askNode,
             };
         }
-        else if (bidSlot.lte(askSlot) && !askNode.order.postOnly) {
+        else if (askSlot.lte(bidSlot)) {
             return {
-                takerNode: askNode,
-                makerNode: bidNode,
+                takerNode: bidNode,
+                makerNode: askNode,
             };
         }
         else {
-            return undefined;
+            return {
+                takerNode: askNode,
+                makerNode: bidNode,
+            };
         }
     }
     getBestAsk(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {

package/lib/dlob/NodeList.d.ts

@@ -21,7 +21,7 @@ export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLO
     remove(order: Order, userAccount: PublicKey): void;
     getGenerator(): Generator<DLOBNode>;
     has(order: Order, userAccount: PublicKey): boolean;
-    get(orderId: number, userAccount: PublicKey): DLOBNodeMap[NodeType] | undefined;
+    get(orderSignature: string): DLOBNodeMap[NodeType] | undefined;
     print(): void;
     printTop(): void;
 }

package/lib/dlob/NodeList.js

@@ -104,8 +104,8 @@ class NodeList {
     has(order, userAccount) {
         return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
     }
-    get(orderId, userAccount) {
-        return this.nodeMap.get(getOrderSignature(orderId, userAccount));
+    get(orderSignature) {
+        return this.nodeMap.get(orderSignature);
     }
     print() {
         let currentNode = this.head;

package/lib/factory/oracleClient.js

@@ -10,9 +10,12 @@ function getOracleClient(oracleSource, connection) {
     if (types_1.isVariant(oracleSource, 'pyth')) {
         return new pythClient_1.PythClient(connection);
     }
-    if (types_1.isVariant(oracleSource, 'pyth1000')) {
+    if (types_1.isVariant(oracleSource, 'pyth1K')) {
         return new pythClient_1.PythClient(connection, new anchor_1.BN(1000));
     }
+    if (types_1.isVariant(oracleSource, 'pyth1M')) {
+        return new pythClient_1.PythClient(connection, new anchor_1.BN(1000000));
+    }
     // if (isVariant(oracleSource, 'switchboard')) {
     // 	return new SwitchboardClient(connection);
     // }

package/lib/idl/drift.json

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

package/lib/math/amm.js

@@ -203,26 +203,21 @@ function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBas
 exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
 function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, directionalSpread, maxSpread) {
     if (baseAssetAmountWithAmm.eq(numericConstants_1.ZERO)) {
-        return 0;
+        return 1;
     }
-    const defaultLargeBidAskFactor = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
+    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
     // inventory skew
     const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
-    const minSideLiquidity = anchor_1.BN.max(new anchor_1.BN(1), anchor_1.BN.min(openBids.abs(), openAsks.abs()));
-    const inventoryScaleMaxBN = anchor_1.BN.max(defaultLargeBidAskFactor, new anchor_1.BN(maxSpread / 2)
+    const minSideLiquidity = anchor_1.BN.min(openBids.abs(), openAsks.abs());
+    const inventoryScaleBN = anchor_1.BN.min(baseAssetAmountWithAmm
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(anchor_1.BN.max(minSideLiquidity, numericConstants_1.ONE))
+        .abs(), numericConstants_1.PERCENTAGE_PRECISION);
+    const inventoryScaleMaxBN = anchor_1.BN.max(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, new anchor_1.BN(maxSpread)
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(new anchor_1.BN(Math.max(directionalSpread, 1))));
-    const inventoryScaleBN = baseAssetAmountWithAmm
-        .mul(anchor_1.BN.max(baseAssetAmountWithAmm.abs(), numericConstants_1.BASE_PRECISION))
-        .div(numericConstants_1.BASE_PRECISION)
-        .mul(defaultLargeBidAskFactor)
-        .div(minSideLiquidity)
-        .abs();
-    const inventoryScale = anchor_1.BN.min(inventoryScaleMaxBN, inventoryScaleBN).toNumber() /
-        numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
-    const inventoryScaleMax = inventoryScaleMaxBN.toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
-    const inventorySpreadScale = Math.min(inventoryScaleMax, 1 + inventoryScale);
-    return inventorySpreadScale;
+    const inventoryScaleCapped = anchor_1.BN.min(inventoryScaleMaxBN, numericConstants_1.BID_ASK_SPREAD_PRECISION.add(inventoryScaleMaxBN.mul(inventoryScaleBN).div(numericConstants_1.PERCENTAGE_PRECISION))).toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
+    return inventoryScaleCapped;
 }
 exports.calculateInventoryScale = calculateInventoryScale;
 function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions) {

package/lib/math/trade.js

@@ -499,7 +499,7 @@ function calculateEstimatedSpotEntryPrice(assetType, amount, direction, market,
                     .div(basePrecision);
                 cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
                 cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
-                worstPrice = dlobLimitOrder;
+                worstPrice = dlobLimitOrderPrice;
                 dlobLimitOrder = dlobLimitOrders.next().value;
             }
             else {

package/lib/serum/serumSubscriber.d.ts

@@ -8,16 +8,17 @@ export declare 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;
     constructor(config: SerumMarketSubscriberConfig);
     subscribe(): Promise<void>;

package/lib/serum/serumSubscriber.js

@@ -9,7 +9,13 @@ class SerumSubscriber {
         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';
+        }
     }
     async subscribe() {
         if (this.subscribed) {
@@ -18,16 +24,32 @@ class SerumSubscriber {
         this.market = await serum_1.Market.load(this.connection, this.marketAddress, undefined, this.programId);
         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 = serum_1.Orderbook.decode(this.market, buffer);
-        });
+        if (this.subscriptionType === 'websocket') {
+            this.asksCallbackId = this.connection.onAccountChange(this.asksAddress, (accountInfo, ctx) => {
+                this.lastAsksSlot = ctx.slot;
+                this.asks = serum_1.Orderbook.decode(this.market, accountInfo.data);
+            });
+        }
+        else {
+            this.asksCallbackId = await this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
+                this.lastAsksSlot = slot;
+                this.asks = serum_1.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 = serum_1.Orderbook.decode(this.market, buffer);
-        });
+        if (this.subscriptionType === 'websocket') {
+            this.bidsCallbackId = this.connection.onAccountChange(this.bidsAddress, (accountInfo, ctx) => {
+                this.lastBidsSlot = ctx.slot;
+                this.bids = serum_1.Orderbook.decode(this.market, accountInfo.data);
+            });
+        }
+        else {
+            this.bidsCallbackId = await this.accountLoader.addAccount(this.bidsAddress, (buffer, slot) => {
+                this.lastBidsSlot = slot;
+                this.bids = serum_1.Orderbook.decode(this.market, buffer);
+            });
+        }
         this.subscribed = true;
     }
     getBestBid() {
@@ -48,8 +70,15 @@ class SerumSubscriber {
         if (!this.subscribed) {
             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);
+            await this.connection.removeAccountChangeListener(this.bidsCallbackId);
+        }
+        else {
+            this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+            this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+        }
         this.subscribed = false;
     }
 }

package/lib/serum/types.d.ts

@@ -7,5 +7,7 @@ export declare type SerumMarketSubscriberConfig = {
     accountSubscription: {
         type: 'polling';
         accountLoader: BulkAccountLoader;
+    } | {
+        type: 'websocket';
     };
 };

package/lib/types.d.ts

@@ -130,8 +130,11 @@ export declare class OracleSource {
     static readonly PYTH: {
         pyth: {};
     };
-    static readonly PYTH_1000: {
-        pyth1000: {};
+    static readonly PYTH_1K: {
+        pyth1K: {};
+    };
+    static readonly PYTH_1M: {
+        pyth1M: {};
     };
     static readonly QUOTE_ASSET: {
         quoteAsset: {};

package/lib/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.18.0",
+	"version": "2.19.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/constants/perpMarkets.ts

@@ -57,12 +57,12 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 	{
 		fullName: 'Bonk',
 		category: ['Meme'],
-		symbol: 'BONK-PERP',
-		baseAssetSymbol: 'BONK',
+		symbol: '1MBONK-PERP',
+		baseAssetSymbol: '1MBONK',
 		marketIndex: 4,
 		oracle: new PublicKey('6bquU99ktV1VRiHDr8gMhDFt3kMfhCQo5nfNrg2Urvsn'),
 		launchTs: 1677068931000,
-		oracleSource: OracleSource.PYTH_1000,
+		oracleSource: OracleSource.PYTH_1M,
 	},
 ];
 
@@ -107,6 +107,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1675802661000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'Bonk',
+		category: ['Meme'],
+		symbol: '1MBONK-PERP',
+		baseAssetSymbol: '1MBONK',
+		marketIndex: 4,
+		oracle: new PublicKey('8ihFLu5FimgTQ1Unh4dVyEHUGodJ5gJQCrQf4KUVB9bN'),
+		launchTs: 1677690149000,
+		oracleSource: OracleSource.PYTH_1M,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/dlob/DLOB.ts

@@ -450,8 +450,9 @@ export class DLOB {
 	}
 
 	public getOrder(orderId: number, userAccount: PublicKey): Order | undefined {
+		const orderSignature = getOrderSignature(orderId, userAccount);
 		for (const nodeList of this.getNodeLists()) {
-			const node = nodeList.get(orderId, userAccount);
+			const node = nodeList.get(orderSignature);
 			if (node) {
 				return node.order;
 			}
@@ -1383,18 +1384,29 @@ export class DLOB {
 		const bidSlot = bidNode.order.slot.add(
 			new BN(bidNode.order.auctionDuration)
 		);
-		if (askSlot.lte(bidSlot) && !bidNode.order.postOnly) {
+
+		if (bidNode.order.postOnly && askNode.order.postOnly) {
+			return undefined;
+		} else if (bidNode.order.postOnly) {
+			return {
+				takerNode: askNode,
+				makerNode: bidNode,
+			};
+		} else if (askNode.order.postOnly) {
 			return {
 				takerNode: bidNode,
 				makerNode: askNode,
 			};
-		} else if (bidSlot.lte(askSlot) && !askNode.order.postOnly) {
+		} else if (askSlot.lte(bidSlot)) {
+			return {
+				takerNode: bidNode,
+				makerNode: askNode,
+			};
+		} else {
 			return {
 				takerNode: askNode,
 				makerNode: bidNode,
 			};
-		} else {
-			return undefined;
 		}
 	}
 

package/src/dlob/NodeList.ts

@@ -146,11 +146,8 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 		return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
 	}
 
-	public get(
-		orderId: number,
-		userAccount: PublicKey
-	): DLOBNodeMap[NodeType] | undefined {
-		return this.nodeMap.get(getOrderSignature(orderId, userAccount));
+	public get(orderSignature: string): DLOBNodeMap[NodeType] | undefined {
+		return this.nodeMap.get(orderSignature);
 	}
 
 	public print(): void {

package/src/factory/oracleClient.ts

@@ -14,10 +14,14 @@ export function getOracleClient(
 		return new PythClient(connection);
 	}
 
-	if (isVariant(oracleSource, 'pyth1000')) {
+	if (isVariant(oracleSource, 'pyth1K')) {
 		return new PythClient(connection, new BN(1000));
 	}
 
+	if (isVariant(oracleSource, 'pyth1M')) {
+		return new PythClient(connection, new BN(1000000));
+	}
+
 	// if (isVariant(oracleSource, 'switchboard')) {
 	// 	return new SwitchboardClient(connection);
 	// }

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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);