@drift-labs/sdk 2.20.0-beta.0 → 2.20.0-beta.1

package/src/dlob/DLOB.ts

@@ -60,7 +60,7 @@ type OrderBookCallback = () => void;
 
 export type NodeToFill = {
 	node: DLOBNode;
-	makerNode?: DLOBNode;
+	makerNodes: DLOBNode[];
 };
 
 export type NodeToTrigger = {
@@ -512,10 +512,53 @@ export class DLOB {
 			ts,
 			marketType
 		);
-		return restingLimitOrderNodesToFill.concat(
-			takingOrderNodesToFill,
-			expiredNodesToFill
-		);
+
+		// for spot, multiple makers isn't supported, so don't merge
+		if (isVariant(marketType, 'spot')) {
+			return restingLimitOrderNodesToFill.concat(
+				takingOrderNodesToFill,
+				expiredNodesToFill
+			);
+		}
+
+		return this.mergeNodesToFill(
+			restingLimitOrderNodesToFill,
+			takingOrderNodesToFill
+		).concat(expiredNodesToFill);
+	}
+
+	mergeNodesToFill(
+		restingLimitOrderNodesToFill: NodeToFill[],
+		takingOrderNodesToFill: NodeToFill[]
+	): NodeToFill[] {
+		const mergedNodesToFill = new Map<string, NodeToFill>();
+
+		const mergeNodesToFillHelper = (nodesToFillArray: NodeToFill[]) => {
+			nodesToFillArray.forEach((nodeToFill) => {
+				const nodeSignature = getOrderSignature(
+					nodeToFill.node.order.orderId,
+					nodeToFill.node.userAccount
+				);
+
+				if (!mergedNodesToFill.has(nodeSignature)) {
+					mergedNodesToFill.set(nodeSignature, {
+						node: nodeToFill.node,
+						makerNodes: [],
+					});
+				}
+
+				if (nodeToFill.makerNodes) {
+					mergedNodesToFill
+						.get(nodeSignature)
+						.makerNodes.push(...nodeToFill.makerNodes);
+				}
+			});
+		};
+
+		mergeNodesToFillHelper(restingLimitOrderNodesToFill);
+		mergeNodesToFillHelper(takingOrderNodesToFill);
+
+		return Array.from(mergedNodesToFill.values());
 	}
 
 	public findRestingLimitOrderNodesToFill(
@@ -768,7 +811,7 @@ export class DLOB {
 
 				nodesToFill.push({
 					node: takerNode,
-					makerNode: makerNode,
+					makerNodes: [makerNode],
 				});
 
 				const makerOrder = makerNode.order;
@@ -847,7 +890,7 @@ export class DLOB {
 			if (crosses && fallbackAvailable) {
 				nodesToFill.push({
 					node: node,
-					makerNode: undefined, // filled by fallback
+					makerNodes: [], // filled by fallback
 				});
 			}
 
@@ -890,6 +933,7 @@ export class DLOB {
 				if (isOrderExpired(bid.order, ts)) {
 					nodesToFill.push({
 						node: bid,
+						makerNodes: [],
 					});
 				}
 			}
@@ -900,6 +944,7 @@ export class DLOB {
 				if (isOrderExpired(ask.order, ts)) {
 					nodesToFill.push({
 						node: ask,
+						makerNodes: [],
 					});
 				}
 			}
@@ -924,6 +969,7 @@ export class DLOB {
 		)) {
 			nodesToFill.push({
 				node: marketBid,
+				makerNodes: [],
 			});
 		}
 
@@ -935,6 +981,7 @@ export class DLOB {
 		)) {
 			nodesToFill.push({
 				node: marketAsk,
+				makerNodes: [],
 			});
 		}
 		return nodesToFill;
@@ -1362,7 +1409,7 @@ export class DLOB {
 
 				nodesToFill.push({
 					node: takerNode,
-					makerNode: makerNode,
+					makerNodes: [makerNode],
 				});
 
 				if (newAskOrder.baseAssetAmount.eq(newAskOrder.baseAssetAmountFilled)) {

package/src/driftClient.ts

@@ -28,6 +28,8 @@ import {
 	OrderTriggerCondition,
 	isOneOfVariant,
 	PostOnlyParams,
+	SpotBalanceType,
+	PerpMarketExtendedInfo,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import driftIDL from './idl/drift.json';
@@ -85,6 +87,7 @@ import { configs, getMarketsAndOraclesForSubscription } from './config';
 import { WRAPPED_SOL_MINT } from './constants/spotMarkets';
 import { UserStats } from './userStats';
 import { isSpotPositionAvailable } from './math/spotPosition';
+import { calculateMarketMaxAvailableInsurance } from './math/market';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -4155,6 +4158,31 @@ export class DriftClient {
 		);
 	}
 
+	public getPerpMarketExtendedInfo(
+		marketIndex: number
+	): PerpMarketExtendedInfo {
+		const marketAccount = this.getPerpMarketAccount(marketIndex);
+		const quoteAccount = this.getSpotMarketAccount(QUOTE_SPOT_MARKET_INDEX);
+
+		const extendedInfo: PerpMarketExtendedInfo = {
+			marketIndex,
+			minOrderSize: marketAccount.amm?.minOrderSize,
+			marginMaintenance: marketAccount.marginRatioMaintenance,
+			pnlPoolValue: getTokenAmount(
+				marketAccount.pnlPool?.scaledBalance,
+				quoteAccount,
+				SpotBalanceType.DEPOSIT
+			),
+			contractTier: marketAccount.contractTier,
+			availableInsurance: calculateMarketMaxAvailableInsurance(
+				marketAccount,
+				quoteAccount
+			),
+		};
+
+		return extendedInfo;
+	}
+
 	sendTransaction(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.20.0-beta.0",
+  "version": "2.20.0-beta.1",
   "name": "drift",
   "instructions": [
     {

package/src/math/orders.ts

@@ -217,9 +217,13 @@ export function calculateBaseAssetAmountToFillUpToLimitPrice(
 	limitPrice: BN,
 	oraclePriceData: OraclePriceData
 ): BN {
+	const adjustedLimitPrice = isVariant(order.direction, 'long')
+		? limitPrice.sub(amm.orderTickSize)
+		: limitPrice.add(amm.orderTickSize);
+
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
 		amm,
-		limitPrice,
+		adjustedLimitPrice,
 		order.direction,
 		oraclePriceData
 	);

package/src/types.ts

@@ -998,3 +998,25 @@ export type SerumV3FulfillmentConfigAccount = {
 	serumOpenOrders: PublicKey;
 	serumSignerNonce: BN;
 };
+
+export type PerpMarketExtendedInfo = {
+	marketIndex: number;
+	/**
+	 * Min order size measured in base asset, using base precision
+	 */
+	minOrderSize: BN;
+	/**
+	 * Margin maintenance percentage, using margin precision (1e4)
+	 */
+	marginMaintenance: number;
+	/**
+	 * Max insurance available, measured in quote asset, using quote preicision
+	 */
+	availableInsurance: BN;
+	/**
+	 * Pnl pool available, this is measured in quote asset, using quote precision.
+	 * Should be generated by using getTokenAmount and passing in the scaled balance of the base asset + quote spot account
+	 */
+	pnlPoolValue: BN;
+	contractTier: ContractTier;
+};

package/src/userMap/userStatsMap.ts

@@ -52,10 +52,7 @@ export class UserStatsMap {
 
 			const chUserStat = new UserStats({
 				driftClient: this.driftClient,
-				userStatsAccountPublicKey: getUserStatsAccountPublicKey(
-					this.driftClient.program.programId,
-					userStat.authority
-				),
+				userStatsAccountPublicKey: programUserAccount.publicKey,
 				accountSubscription: this.accountSubscription,
 			});
 			userStatArray.push(chUserStat);

package/tests/amm/test.ts

@@ -45,7 +45,7 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		assert(iscale == 1);
 
@@ -55,42 +55,42 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		assert(iscale == 1);
 
-		let baa = new BN(1000); 
+		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,
+			30000
 		);
 		console.log(iscale);
 		assert(iscale == 1.00024);
 
-		baa = new BN(100000); 
+		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,
+			30000
 		);
 		console.log(iscale);
 		assert(iscale == 1.024);
 
-		baa = new BN(1000000); 
+		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,
+			30000
 		);
 		console.log(iscale);
 		assert(iscale == 1.24048);
@@ -102,7 +102,7 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		console.log(iscale);
 		assert(iscale == 3.44896);
@@ -114,12 +114,11 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		console.log(iscale);
 		assert(iscale == 14.33332);
 
-
 		baa = AMM_RESERVE_PRECISION.div(new BN(4)); // 50%
 		iscale = calculateInventoryScale(
 			baa,
@@ -127,7 +126,7 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		console.log(iscale);
 		assert(iscale == 120); //100%
@@ -139,7 +138,7 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000 * 2,
+			30000 * 2
 		);
 		console.log(iscale);
 		assert(iscale == 120 * 2); //100%
@@ -151,21 +150,21 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000 * 2,
+			30000 * 2
 		);
-		assert(iscale == 160.99984); 
+		assert(iscale == 160.99984);
 
-		baa = new BN(855329058); 
+		baa = new BN(855329058);
 		iscale = calculateInventoryScale(
 			baa,
 			AMM_RESERVE_PRECISION.add(baa),
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION,
 			250,
-			30000,
+			30000
 		); // >100%
 		assert(iscale == 120);
-		assert(250*iscale == 30000);
+		assert(250 * iscale == 30000);
 
 		iscale = calculateInventoryScale(
 			baa,
@@ -173,10 +172,10 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		assert(iscale == 120);
-		assert(250*iscale == 30000);
+		assert(250 * iscale == 30000);
 
 		baa = new BN(-855329058); // ~85%
 		iscale = calculateInventoryScale(
@@ -185,10 +184,10 @@ describe('AMM Tests', () => {
 			AMM_RESERVE_PRECISION.div(new BN(2)),
 			AMM_RESERVE_PRECISION.mul(new BN(3)).div(new BN(2)),
 			250,
-			30000,
+			30000
 		);
 		assert(iscale == 120);
-		assert(250*iscale == 30000);
+		assert(250 * iscale == 30000);
 
 		// 'bonk' scale
 		iscale = calculateInventoryScale(
@@ -197,15 +196,12 @@ describe('AMM Tests', () => {
 			new BN('2443167585342470000'),
 			new BN('2545411471321696000'),
 			3500,
-			100000,
+			100000
 		);
 		console.log(iscale);
-		console.log(3500*iscale/1e6);
+		console.log((3500 * iscale) / 1e6);
 		assert(iscale == 18.762285);
-		assert(3500*iscale/1e6 == 0.06566799749999999); //6.5%
-
-
-
+		assert((3500 * iscale) / 1e6 == 0.06566799749999999); //6.5%
 	});
 
 	it('Various Spreads', () => {