@drift-labs/sdk 2.18.0 → 2.20.0-beta.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/driftClient.d.ts

@@ -186,8 +186,8 @@ export declare class DriftClient {
     getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
     cancelOrders(marketType?: MarketType, marketIndex?: number, direction?: PositionDirection, txParams?: TxParams): Promise<TransactionSignature>;
     getCancelOrdersIx(marketType: MarketType | null, marketIndex: number | null, direction: PositionDirection | null): Promise<TransactionInstruction>;
-    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
+    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
     placeSpotOrder(orderParams: OptionalOrderParams, txParams?: TxParams): Promise<TransactionSignature>;
     getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
     fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;

package/lib/driftClient.js

@@ -1261,41 +1261,49 @@ class DriftClient {
         const marketIndex = order
             ? order.marketIndex
             : userAccount.orders.find((order) => order.orderId === userAccount.nextOrderId - 1).marketIndex;
+        makerInfo = Array.isArray(makerInfo)
+            ? makerInfo
+            : makerInfo
+                ? [makerInfo]
+                : [];
         const userAccounts = [userAccount];
-        if (makerInfo !== undefined) {
-            userAccounts.push(makerInfo.makerUserAccount);
+        for (const maker of makerInfo) {
+            userAccounts.push(maker.makerUserAccount);
         }
         const remainingAccounts = this.getRemainingAccounts({
             userAccounts,
             writablePerpMarketIndexes: [marketIndex],
         });
-        if (makerInfo) {
+        for (const maker of makerInfo) {
             remainingAccounts.push({
-                pubkey: makerInfo.maker,
+                pubkey: maker.maker,
                 isWritable: true,
                 isSigner: false,
             });
             remainingAccounts.push({
-                pubkey: makerInfo.makerStats,
+                pubkey: maker.makerStats,
                 isWritable: true,
                 isSigner: false,
             });
         }
         if (referrerInfo) {
-            remainingAccounts.push({
-                pubkey: referrerInfo.referrer,
-                isWritable: true,
-                isSigner: false,
-            });
-            remainingAccounts.push({
-                pubkey: referrerInfo.referrerStats,
-                isWritable: true,
-                isSigner: false,
-            });
+            const referrerIsMaker = makerInfo.find((maker) => maker.maker.equals(referrerInfo.referrer)) !==
+                undefined;
+            if (!referrerIsMaker) {
+                remainingAccounts.push({
+                    pubkey: referrerInfo.referrer,
+                    isWritable: true,
+                    isSigner: false,
+                });
+                remainingAccounts.push({
+                    pubkey: referrerInfo.referrerStats,
+                    isWritable: true,
+                    isSigner: false,
+                });
+            }
         }
         const orderId = order.orderId;
-        const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
-        return await this.program.instruction.fillPerpOrder(orderId, makerOrderId, {
+        return await this.program.instruction.fillPerpOrder(orderId, null, {
             accounts: {
                 state: await this.getStatePublicKey(),
                 filler: fillerPublicKey,

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.20.0-beta.0",
     "name": "drift",
     "instructions": [
         {
@@ -6207,6 +6207,7 @@
                     {
                         "name": "Match",
                         "fields": [
+                            "publicKey",
                             {
                                 "defined": "usize"
                             }
@@ -6237,14 +6238,17 @@
                     {
                         "name": "Pyth"
                     },
-                    {
-                        "name": "Pyth1000"
-                    },
                     {
                         "name": "Switchboard"
                     },
                     {
                         "name": "QuoteAsset"
+                    },
+                    {
+                        "name": "Pyth1K"
+                    },
+                    {
+                        "name": "Pyth1M"
                     }
                 ]
             }
@@ -8601,6 +8605,56 @@
             "code": 6227,
             "name": "TierViolationLiquidatingPerpPnl",
             "msg": "TierViolationLiquidatingPerpPnl"
+        },
+        {
+            "code": 6228,
+            "name": "CouldNotLoadUserData",
+            "msg": "CouldNotLoadUserData"
+        },
+        {
+            "code": 6229,
+            "name": "UserWrongMutability",
+            "msg": "UserWrongMutability"
+        },
+        {
+            "code": 6230,
+            "name": "InvalidUserAccount",
+            "msg": "InvalidUserAccount"
+        },
+        {
+            "code": 6231,
+            "name": "CouldNotLoadUserStatsData",
+            "msg": "CouldNotLoadUserData"
+        },
+        {
+            "code": 6232,
+            "name": "UserStatsWrongMutability",
+            "msg": "UserWrongMutability"
+        },
+        {
+            "code": 6233,
+            "name": "InvalidUserStatsAccount",
+            "msg": "InvalidUserAccount"
+        },
+        {
+            "code": 6234,
+            "name": "UserNotFound",
+            "msg": "UserNotFound"
+        },
+        {
+            "code": 6235,
+            "name": "UnableToLoadUserAccount",
+            "msg": "UnableToLoadUserAccount"
+        },
+        {
+            "code": 6236,
+            "name": "UserStatsNotFound",
+            "msg": "UserStatsNotFound"
+        },
+        {
+            "code": 6237,
+            "name": "UnableToLoadUserStatsAccount",
+            "msg": "UnableToLoadUserStatsAccount"
         }
     ]
 }

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: {};
@@ -925,7 +928,7 @@ export declare type MakerInfo = {
     maker: PublicKey;
     makerStats: PublicKey;
     makerUserAccount: UserAccount;
-    order: Order;
+    order?: Order;
 };
 export declare type TakerInfo = {
     taker: PublicKey;

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.20.0-beta.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/driftClient.ts

@@ -2214,7 +2214,7 @@ export class DriftClient {
 		userAccountPublicKey: PublicKey,
 		user: UserAccount,
 		order?: Pick<Order, 'marketIndex' | 'orderId'>,
-		makerInfo?: MakerInfo,
+		makerInfo?: MakerInfo | MakerInfo[],
 		referrerInfo?: ReferrerInfo,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
@@ -2240,7 +2240,7 @@ export class DriftClient {
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
 		order: Pick<Order, 'marketIndex' | 'orderId'>,
-		makerInfo?: MakerInfo,
+		makerInfo?: MakerInfo | MakerInfo[],
 		referrerInfo?: ReferrerInfo
 	): Promise<TransactionInstruction> {
 		const userStatsPublicKey = getUserStatsAccountPublicKey(
@@ -2257,45 +2257,54 @@ export class DriftClient {
 					(order) => order.orderId === userAccount.nextOrderId - 1
 			  ).marketIndex;
 
+		makerInfo = Array.isArray(makerInfo)
+			? makerInfo
+			: makerInfo
+			? [makerInfo]
+			: [];
+
 		const userAccounts = [userAccount];
-		if (makerInfo !== undefined) {
-			userAccounts.push(makerInfo.makerUserAccount);
+		for (const maker of makerInfo) {
+			userAccounts.push(maker.makerUserAccount);
 		}
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts,
 			writablePerpMarketIndexes: [marketIndex],
 		});
 
-		if (makerInfo) {
+		for (const maker of makerInfo) {
 			remainingAccounts.push({
-				pubkey: makerInfo.maker,
+				pubkey: maker.maker,
 				isWritable: true,
 				isSigner: false,
 			});
 			remainingAccounts.push({
-				pubkey: makerInfo.makerStats,
+				pubkey: maker.makerStats,
 				isWritable: true,
 				isSigner: false,
 			});
 		}
 
 		if (referrerInfo) {
-			remainingAccounts.push({
-				pubkey: referrerInfo.referrer,
-				isWritable: true,
-				isSigner: false,
-			});
-			remainingAccounts.push({
-				pubkey: referrerInfo.referrerStats,
-				isWritable: true,
-				isSigner: false,
-			});
+			const referrerIsMaker =
+				makerInfo.find((maker) => maker.maker.equals(referrerInfo.referrer)) !==
+				undefined;
+			if (!referrerIsMaker) {
+				remainingAccounts.push({
+					pubkey: referrerInfo.referrer,
+					isWritable: true,
+					isSigner: false,
+				});
+				remainingAccounts.push({
+					pubkey: referrerInfo.referrerStats,
+					isWritable: true,
+					isSigner: false,
+				});
+			}
 		}
 
 		const orderId = order.orderId;
-		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
-
-		return await this.program.instruction.fillPerpOrder(orderId, makerOrderId, {
+		return await this.program.instruction.fillPerpOrder(orderId, null, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				filler: fillerPublicKey,

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.20.0-beta.0",
   "name": "drift",
   "instructions": [
     {
@@ -6207,6 +6207,7 @@
           {
             "name": "Match",
             "fields": [
+              "publicKey",
               {
                 "defined": "usize"
               }
@@ -6237,14 +6238,17 @@
           {
             "name": "Pyth"
           },
-          {
-            "name": "Pyth1000"
-          },
           {
             "name": "Switchboard"
           },
           {
             "name": "QuoteAsset"
+          },
+          {
+            "name": "Pyth1K"
+          },
+          {
+            "name": "Pyth1M"
           }
         ]
       }
@@ -8601,6 +8605,56 @@
       "code": 6227,
       "name": "TierViolationLiquidatingPerpPnl",
       "msg": "TierViolationLiquidatingPerpPnl"
+    },
+    {
+      "code": 6228,
+      "name": "CouldNotLoadUserData",
+      "msg": "CouldNotLoadUserData"
+    },
+    {
+      "code": 6229,
+      "name": "UserWrongMutability",
+      "msg": "UserWrongMutability"
+    },
+    {
+      "code": 6230,
+      "name": "InvalidUserAccount",
+      "msg": "InvalidUserAccount"
+    },
+    {
+      "code": 6231,
+      "name": "CouldNotLoadUserStatsData",
+      "msg": "CouldNotLoadUserData"
+    },
+    {
+      "code": 6232,
+      "name": "UserStatsWrongMutability",
+      "msg": "UserWrongMutability"
+    },
+    {
+      "code": 6233,
+      "name": "InvalidUserStatsAccount",
+      "msg": "InvalidUserAccount"
+    },
+    {
+      "code": 6234,
+      "name": "UserNotFound",
+      "msg": "UserNotFound"
+    },
+    {
+      "code": 6235,
+      "name": "UnableToLoadUserAccount",
+      "msg": "UnableToLoadUserAccount"
+    },
+    {
+      "code": 6236,
+      "name": "UserStatsNotFound",
+      "msg": "UserStatsNotFound"
+    },
+    {
+      "code": 6237,
+      "name": "UnableToLoadUserStatsAccount",
+      "msg": "UnableToLoadUserStatsAccount"
     }
   ]
 }

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: {} };
 }
@@ -901,7 +902,7 @@ export type MakerInfo = {
 	maker: PublicKey;
 	makerStats: PublicKey;
 	makerUserAccount: UserAccount;
-	order: Order;
+	order?: Order;
 };
 
 export type TakerInfo = {

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);