@drift-labs/sdk 2.11.0 → 2.12.0-beta.1

package/README.md

@@ -11,14 +11,6 @@
   </p>
 </div>
 
-# Drift Protocol v2
-
-This repository provides open source access to Drift's Typescript SDK, Solana Programs, and more.
-
-# SDK Guide
-
-The technical documentation for the SDK can be found [here](https://drift-labs.github.io/protocol-v2/sdk/), and you can visit Drift's general purpose documentation [here](https://docs.drift.trade/sdk-documentation).
-
 ## Installation
 
 ```
@@ -84,7 +76,7 @@ convertToNumber(new BN(10500), new BN(1000)); // = 10.5
 ### Setting up an account and making a trade
 
 ```typescript
-import { BN, Provider } from '@project-serum/anchor';
+import { AnchorProvider, BN } from '@project-serum/anchor';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
@@ -92,14 +84,18 @@ import {
 	DriftClient,
 	User,
 	initialize,
-	Markets,
 	PositionDirection,
 	convertToNumber,
 	calculateTradeSlippage,
 	PRICE_PRECISION,
 	QUOTE_PRECISION,
 	Wallet,
-} from '@drift-labs/sdk';
+	PerpMarkets,
+	BASE_PRECISION,
+	getMarketOrderParams,
+	BulkAccountLoader,
+	getMarketsAndOraclesForSubscription
+} from '../sdk';
 
 export const getTokenAddress = (
 	mintAddress: string,
@@ -114,8 +110,9 @@ export const getTokenAddress = (
 };
 
 const main = async () => {
+	const env = 'devnet';
 	// Initialize Drift SDK
-	const sdkConfig = initialize({ env: 'devnet' });
+	const sdkConfig = initialize({ env });
 
 	// Set up the Wallet and Provider
 	const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
@@ -129,7 +126,11 @@ const main = async () => {
 	const connection = new Connection(rpcAddress);
 
 	// Set up the Provider
-	const provider = new Provider(connection, wallet, Provider.defaultOptions());
+	const provider = new AnchorProvider(
+		connection,
+		wallet,
+		AnchorProvider.defaultOptions()
+	);
 
 	// Check SOL Balance
 	const lamportsBalance = await connection.getBalance(wallet.publicKey);
@@ -142,18 +143,35 @@ const main = async () => {
 	);
 
 	// Set up the Drift Client
-	const driftClientPublicKey = new PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
-	const driftClient = DriftClient.from(
+	const driftPublicKey = new PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
+	const bulkAccountLoader = new BulkAccountLoader(
 		connection,
-		provider.wallet,
-		driftClientPublicKey
+		'confirmed',
+		1000
 	);
+	const driftClient = new DriftClient({
+		connection,
+		wallet: provider.wallet,
+		programID: driftPublicKey,
+		...getMarketsAndOraclesForSubscription(env),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
 	await driftClient.subscribe();
 
-	// Set up Clearing House user client
-	const user = User.from(driftClient, wallet.publicKey);
-
-	//// Check if clearing house account exists for the current wallet
+	// Set up user client
+	const user = new User({
+		driftClient: driftClient,
+		userAccountPublicKey: await driftClient.getUserAccountPublicKey(),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
+	});
+
+	//// Check if user account exists for the current wallet
 	const userAccountExists = await user.exists();
 
 	if (!userAccountExists) {
@@ -171,51 +189,48 @@ const main = async () => {
 	await user.subscribe();
 
 	// Get current price
-	const solMarketInfo = Markets.find(
+	const solMarketInfo = PerpMarkets[env].find(
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
-	const currentMarketPrice = calculateReservePrice(
-		driftClient.getMarket(solMarketInfo.marketIndex)
+	const [bid, ask] = calculateBidAskPrice(
+		driftClient.getPerpMarketAccount(marketIndex).amm,
+		driftClient.getOracleDataForPerpMarket(marketIndex)
 	);
 
-	const formattedPrice = convertToNumber(currentMarketPrice, PRICE_PRECISION);
+	const formattedBidPrice = convertToNumber(bid, PRICE_PRECISION);
+	const formattedAskPrice = convertToNumber(ask, PRICE_PRECISION);
 
-	console.log(`Current Market Price is $${formattedPrice}`);
+	console.log(
+		`Current amm bid and ask price are $${formattedBidPrice} and $${formattedAskPrice}`
+	);
 
 	// Estimate the slippage for a $5000 LONG trade
-	const solMarketAccount = driftClient.getMarket(solMarketInfo.marketIndex);
+	const solMarketAccount = driftClient.getPerpMarketAccount(
+		solMarketInfo.marketIndex
+	);
 
 	const slippage = convertToNumber(
 		calculateTradeSlippage(
 			PositionDirection.LONG,
-			new BN(5000).mul(QUOTE_PRECISION),
-			solMarketAccount
+			new BN(1).mul(BASE_PRECISION),
+			solMarketAccount,
+			'base',
+			driftClient.getOracleDataForPerpMarket(solMarketInfo.marketIndex)
 		)[0],
 		PRICE_PRECISION
 	);
 
-	console.log(
-		`Slippage for a $5000 LONG on the SOL market would be $${slippage}`
-	);
+	console.log(`Slippage for a 1 SOL-PERP would be $${slippage}`);
 
-	// Make a $5000 LONG trade
-	await driftClient.openPosition(
-		PositionDirection.LONG,
-		new BN(5000).mul(QUOTE_PRECISION),
-		solMarketInfo.marketIndex
+	await driftClient.placePerpOrder(
+		getMarketOrderParams({
+			baseAssetAmount: new BN(1).mul(BASE_PRECISION),
+			direction: PositionDirection.LONG,
+			marketIndex: solMarketAccount.marketIndex,
+		})
 	);
-	console.log(`LONGED $5000 worth of SOL`);
-
-	// Reduce the position by $2000
-	await driftClient.openPosition(
-		PositionDirection.SHORT,
-		new BN(2000).mul(QUOTE_PRECISION),
-		solMarketInfo.marketIndex
-	);
-
-	// Close the rest of the position
-	await driftClient.closePosition(solMarketInfo.marketIndex);
+	console.log(`Placed a 1 SOL-PERP LONG order`);
 };
 
 main();

package/lib/dlob/DLOB.d.ts

@@ -64,7 +64,22 @@ export declare class DLOB {
     getMarketAsks(marketIndex: number, marketType: MarketType): Generator<DLOBNode>;
     private getBestNode;
     getLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    /**
+     * Filters the limit asks that are post only or have been place for sufficiently long
+     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     *
+     * @returns
+     */
+    getRestingLimitAsks(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, minPerpAuctionDuration: number): Generator<DLOBNode>;
+    isRestingLimitOrder(order: Order, slot: number, minPerpAuctionDuration: number): boolean;
     getLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
+    /**
+     * Filters the limit bids that are post only or have been place for sufficiently long
+     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     *
+     * @returns
+     */
+    getRestingLimitBids(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, minPerpAuctionDuration: number): Generator<DLOBNode>;
     getAsks(marketIndex: number, fallbackAsk: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     getBids(marketIndex: number, fallbackBid: BN | undefined, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData): Generator<DLOBNode>;
     findCrossingLimitOrders(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];

package/lib/dlob/DLOB.js

@@ -535,6 +535,23 @@ class DLOB {
             return bestPrice.lt(currentPrice);
         });
     }
+    /**
+     * Filters the limit asks that are post only or have been place for sufficiently long
+     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     *
+     * @returns
+     */
+    *getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData, minPerpAuctionDuration) {
+        for (const node of this.getLimitAsks(marketIndex, slot, marketType, oraclePriceData)) {
+            if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+                yield node;
+            }
+        }
+    }
+    isRestingLimitOrder(order, slot, minPerpAuctionDuration) {
+        return (order.postOnly ||
+            new __1.BN(slot).sub(order.slot).gte(new __1.BN(minPerpAuctionDuration * 1.5)));
+    }
     *getLimitBids(marketIndex, slot, marketType, oraclePriceData) {
         if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot bids');
@@ -552,6 +569,19 @@ class DLOB {
             return bestPrice.gt(currentPrice);
         });
     }
+    /**
+     * Filters the limit bids that are post only or have been place for sufficiently long
+     * Useful for displaying order book that doesn't have taker limit orders crossing spread
+     *
+     * @returns
+     */
+    *getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData, minPerpAuctionDuration) {
+        for (const node of this.getLimitBids(marketIndex, slot, marketType, oraclePriceData)) {
+            if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+                yield node;
+            }
+        }
+    }
     *getAsks(marketIndex, fallbackAsk, slot, marketType, oraclePriceData) {
         if ((0, __1.isVariant)(marketType, 'spot') && !oraclePriceData) {
             throw new Error('Must provide OraclePriceData to get spot asks');

package/lib/examples/makeTradeExample.js

@@ -11,10 +11,10 @@ const getTokenAddress = (mintAddress, userPubKey) => {
     return spl_token_1.Token.getAssociatedTokenAddress(new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`), spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
 };
 exports.getTokenAddress = getTokenAddress;
-const cluster = 'devnet';
+const env = 'devnet';
 const main = async () => {
     // Initialize Drift SDK
-    const sdkConfig = (0, __2.initialize)({ env: cluster });
+    const sdkConfig = (0, __2.initialize)({ env });
     // Set up the Wallet and Provider
     const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
     const keypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(JSON.parse(privateKey)));
@@ -36,15 +36,14 @@ const main = async () => {
         connection,
         wallet: provider.wallet,
         programID: driftPublicKey,
-        perpMarketIndexes: __2.PerpMarkets[cluster].map((market) => market.marketIndex),
-        spotMarketIndexes: spotMarkets_1.SpotMarkets[cluster].map((spotMarket) => spotMarket.marketIndex),
+        ...(0, __2.getMarketsAndOraclesForSubscription)(env),
         accountSubscription: {
             type: 'polling',
             accountLoader: bulkAccountLoader,
         },
     });
     await driftClient.subscribe();
-    // Set up Clearing House user client
+    // Set up user client
     const user = new __2.User({
         driftClient: driftClient,
         userAccountPublicKey: await driftClient.getUserAccountPublicKey(),
@@ -53,7 +52,7 @@ const main = async () => {
             accountLoader: bulkAccountLoader,
         },
     });
-    //// Check if clearing house account exists for the current wallet
+    //// Check if user account exists for the current wallet
     const userAccountExists = await user.exists();
     if (!userAccountExists) {
         //// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
@@ -63,21 +62,20 @@ const main = async () => {
     await user.subscribe();
     // Get current price
     const solMarketInfo = sdkConfig.PERP_MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
-    const currentMarketPrice = (0, __2.calculateReservePrice)(driftClient.getPerpMarketAccount(solMarketInfo.marketIndex), undefined);
-    const formattedPrice = (0, __2.convertToNumber)(currentMarketPrice, __2.PRICE_PRECISION);
-    console.log(`Current Market Price is $${formattedPrice}`);
+    const marketIndex = solMarketInfo.marketIndex;
+    const [bid, ask] = (0, __1.calculateBidAskPrice)(driftClient.getPerpMarketAccount(marketIndex).amm, driftClient.getOracleDataForPerpMarket(marketIndex));
+    const formattedBidPrice = (0, __2.convertToNumber)(bid, __2.PRICE_PRECISION);
+    const formattedAskPrice = (0, __2.convertToNumber)(ask, __2.PRICE_PRECISION);
+    console.log(`Current amm bid and ask price are $${formattedBidPrice} and $${formattedAskPrice}`);
     // Estimate the slippage for a $5000 LONG trade
     const solMarketAccount = driftClient.getPerpMarketAccount(solMarketInfo.marketIndex);
-    const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
-    const slippage = (0, __2.convertToNumber)((0, __2.calculateTradeSlippage)(__2.PositionDirection.LONG, longAmount, solMarketAccount, 'quote', undefined)[0], __2.PRICE_PRECISION);
-    console.log(`Slippage for a $5000 LONG on the SOL market would be $${slippage}`);
-    // Make a $5000 LONG trade
-    await driftClient.openPosition(__2.PositionDirection.LONG, longAmount, solMarketInfo.marketIndex);
-    console.log(`LONGED $5000 SOL`);
-    // Reduce the position by $2000
-    const reduceAmount = new anchor_1.BN(2000).mul(__2.QUOTE_PRECISION);
-    await driftClient.openPosition(__2.PositionDirection.SHORT, reduceAmount, solMarketInfo.marketIndex);
-    // Close the rest of the position
-    await driftClient.closePosition(solMarketInfo.marketIndex);
+    const slippage = (0, __2.convertToNumber)((0, __2.calculateTradeSlippage)(__2.PositionDirection.LONG, new anchor_1.BN(1).mul(__1.BASE_PRECISION), solMarketAccount, 'base', driftClient.getOracleDataForPerpMarket(solMarketInfo.marketIndex))[0], __2.PRICE_PRECISION);
+    console.log(`Slippage for a 1 SOL-PERP would be $${slippage}`);
+    await driftClient.placePerpOrder((0, __1.getMarketOrderParams)({
+        baseAssetAmount: new anchor_1.BN(1).mul(__1.BASE_PRECISION),
+        direction: __2.PositionDirection.LONG,
+        marketIndex: solMarketAccount.marketIndex,
+    }));
+    console.log(`Placed a 1 SOL-PERP LONG order`);
 };
 main();

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.11.0",
+    "version": "2.12.0-beta.1",
     "name": "drift",
     "instructions": [
         {
@@ -8568,6 +8568,11 @@
             "code": 6224,
             "name": "MaxNumberOfUsers",
             "msg": "Max Number Of Users"
+        },
+        {
+            "code": 6225,
+            "name": "InvalidOracleForSettlePnl",
+            "msg": "InvalidOracleForSettlePnl"
         }
     ]
 }

package/lib/math/trade.d.ts

@@ -3,6 +3,7 @@ import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 import { OraclePriceData } from '../oracles/types';
+import { DLOB } from '../dlob/DLOB';
 export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
@@ -21,7 +22,7 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  *
  * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
-export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -52,3 +53,17 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  * ]
  */
 export declare function calculateTargetPriceTrade(market: PerpMarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or vamm)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param slot
+ * @param minPerpAuctionDuration
+ */
+export declare function calculateEstimatedPerpEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number, minPerpAuctionDuration: number): [BN, BN];

package/lib/math/trade.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
+exports.calculateEstimatedPerpEntryPrice = exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("@project-serum/anchor");
 const assert_1 = require("../assert/assert");
@@ -247,3 +247,137 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
 }
 exports.calculateTargetPriceTrade = calculateTargetPriceTrade;
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or vamm)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param slot
+ * @param minPerpAuctionDuration
+ */
+function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market, oraclePriceData, dlob, slot, minPerpAuctionDuration) {
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+    }
+    const takerIsLong = (0, types_2.isVariant)(direction, 'long');
+    const limitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, oraclePriceData, minPerpAuctionDuration);
+    const swapDirection = (0, amm_1.getSwapDirection)(assetType, direction);
+    const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
+    const amm = {
+        baseAssetReserve,
+        quoteAssetReserve,
+        sqrtK: sqrtK,
+        pegMultiplier: newPeg,
+    };
+    const invariant = amm.sqrtK.mul(amm.sqrtK);
+    let initialPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    let cumulativeBaseFilled = numericConstants_1.ZERO;
+    let cumulativeQuoteFilled = numericConstants_1.ZERO;
+    let limitOrder = limitOrders.next().value;
+    if (limitOrder) {
+        const limitOrderPrice = limitOrder.getPrice(oraclePriceData, slot);
+        initialPrice = takerIsLong
+            ? anchor_1.BN.min(limitOrderPrice, initialPrice)
+            : anchor_1.BN.max(limitOrderPrice, initialPrice);
+    }
+    if (assetType === 'base') {
+        while (!cumulativeBaseFilled.eq(amount)) {
+            const limitOrderPrice = limitOrder === null || limitOrder === void 0 ? void 0 : limitOrder.getPrice(oraclePriceData, slot);
+            let maxAmmFill;
+            if (limitOrderPrice) {
+                const newBaseReserves = (0, utils_1.squareRootBN)(invariant
+                    .mul(numericConstants_1.PRICE_PRECISION)
+                    .mul(amm.pegMultiplier)
+                    .div(limitOrderPrice)
+                    .div(numericConstants_1.PEG_PRECISION));
+                // will be zero if the limit order price is better than the amm price
+                maxAmmFill = takerIsLong
+                    ? amm.baseAssetReserve.sub(newBaseReserves)
+                    : newBaseReserves.sub(amm.baseAssetReserve);
+            }
+            else {
+                maxAmmFill = amount.sub(cumulativeBaseFilled);
+            }
+            if (maxAmmFill.gt(numericConstants_1.ZERO)) {
+                const baseFilled = anchor_1.BN.min(amount.sub(cumulativeBaseFilled), maxAmmFill);
+                const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'base', baseFilled, swapDirection);
+                const quoteFilled = (0, amm_1.calculateQuoteAssetAmountSwapped)(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                amm.baseAssetReserve = afterSwapBaseReserves;
+                amm.quoteAssetReserve = afterSwapQuoteReserves;
+                if (cumulativeBaseFilled.eq(amount)) {
+                    break;
+                }
+            }
+            const baseFilled = anchor_1.BN.min(limitOrder.order.baseAssetAmount.sub(limitOrder.order.baseAssetAmountFilled), amount.sub(cumulativeBaseFilled));
+            const quoteFilled = baseFilled.mul(limitOrderPrice).div(numericConstants_1.BASE_PRECISION);
+            cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+            cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            if (cumulativeBaseFilled.eq(amount)) {
+                break;
+            }
+            limitOrder = limitOrders.next().value;
+        }
+    }
+    else {
+        while (!cumulativeQuoteFilled.eq(amount)) {
+            const limitOrderPrice = limitOrder === null || limitOrder === void 0 ? void 0 : limitOrder.getPrice(oraclePriceData, slot);
+            let maxAmmFill;
+            if (limitOrderPrice) {
+                const newQuoteReserves = (0, utils_1.squareRootBN)(invariant
+                    .mul(numericConstants_1.PEG_PRECISION)
+                    .mul(limitOrderPrice)
+                    .div(amm.pegMultiplier)
+                    .div(numericConstants_1.PRICE_PRECISION));
+                // will be zero if the limit order price is better than the amm price
+                maxAmmFill = takerIsLong
+                    ? newQuoteReserves.sub(amm.quoteAssetReserve)
+                    : amm.quoteAssetReserve.sub(newQuoteReserves);
+            }
+            else {
+                maxAmmFill = amount.sub(cumulativeQuoteFilled);
+            }
+            if (maxAmmFill.gt(numericConstants_1.ZERO)) {
+                const quoteFilled = anchor_1.BN.min(amount.sub(cumulativeQuoteFilled), maxAmmFill);
+                const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteFilled, swapDirection);
+                const baseFilled = afterSwapBaseReserves
+                    .sub(amm.baseAssetReserve)
+                    .abs();
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                amm.baseAssetReserve = afterSwapBaseReserves;
+                amm.quoteAssetReserve = afterSwapQuoteReserves;
+                if (cumulativeQuoteFilled.eq(amount)) {
+                    break;
+                }
+            }
+            const quoteFilled = anchor_1.BN.min(limitOrder.order.baseAssetAmount
+                .sub(limitOrder.order.baseAssetAmountFilled)
+                .mul(limitOrderPrice)
+                .div(numericConstants_1.BASE_PRECISION), amount.sub(cumulativeQuoteFilled));
+            const baseFilled = quoteFilled.mul(numericConstants_1.BASE_PRECISION).div(limitOrderPrice);
+            cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+            cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            if (cumulativeQuoteFilled.eq(amount)) {
+                break;
+            }
+            limitOrder = limitOrders.next().value;
+        }
+    }
+    const entryPrice = cumulativeQuoteFilled
+        .mul(numericConstants_1.BASE_PRECISION)
+        .div(cumulativeBaseFilled);
+    const priceImpact = entryPrice
+        .sub(initialPrice)
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(initialPrice)
+        .abs();
+    return [entryPrice, priceImpact];
+}
+exports.calculateEstimatedPerpEntryPrice = calculateEstimatedPerpEntryPrice;

package/package.json

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

package/src/dlob/DLOB.ts

@@ -915,6 +915,42 @@ export class DLOB {
 		);
 	}
 
+	/**
+	 * Filters the limit asks that are post only or have been place for sufficiently long
+	 * Useful for displaying order book that doesn't have taker limit orders crossing spread
+	 *
+	 * @returns
+	 */
+	*getRestingLimitAsks(
+		marketIndex: number,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData,
+		minPerpAuctionDuration: number
+	): Generator<DLOBNode> {
+		for (const node of this.getLimitAsks(
+			marketIndex,
+			slot,
+			marketType,
+			oraclePriceData
+		)) {
+			if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+				yield node;
+			}
+		}
+	}
+
+	isRestingLimitOrder(
+		order: Order,
+		slot: number,
+		minPerpAuctionDuration: number
+	): boolean {
+		return (
+			order.postOnly ||
+			new BN(slot).sub(order.slot).gte(new BN(minPerpAuctionDuration * 1.5))
+		);
+	}
+
 	*getLimitBids(
 		marketIndex: number,
 		slot: number,
@@ -947,6 +983,31 @@ export class DLOB {
 		);
 	}
 
+	/**
+	 * Filters the limit bids that are post only or have been place for sufficiently long
+	 * Useful for displaying order book that doesn't have taker limit orders crossing spread
+	 *
+	 * @returns
+	 */
+	*getRestingLimitBids(
+		marketIndex: number,
+		slot: number,
+		marketType: MarketType,
+		oraclePriceData: OraclePriceData,
+		minPerpAuctionDuration: number
+	): Generator<DLOBNode> {
+		for (const node of this.getLimitBids(
+			marketIndex,
+			slot,
+			marketType,
+			oraclePriceData
+		)) {
+			if (this.isRestingLimitOrder(node.order, slot, minPerpAuctionDuration)) {
+				yield node;
+			}
+		}
+	}
+
 	*getAsks(
 		marketIndex: number,
 		fallbackAsk: BN | undefined,

package/src/examples/makeTradeExample.ts

@@ -1,9 +1,13 @@
 import { AnchorProvider, BN } from '@project-serum/anchor';
-import { Wallet } from '..';
+import {
+	BASE_PRECISION,
+	calculateBidAskPrice,
+	getMarketOrderParams,
+	Wallet,
+} from '..';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
-	calculateReservePrice,
 	DriftClient,
 	User,
 	initialize,
@@ -11,7 +15,7 @@ import {
 	convertToNumber,
 	calculateTradeSlippage,
 	BulkAccountLoader,
-	PerpMarkets,
+	getMarketsAndOraclesForSubscription,
 	PRICE_PRECISION,
 	QUOTE_PRECISION,
 } from '..';
@@ -29,11 +33,11 @@ export const getTokenAddress = (
 	);
 };
 
-const cluster = 'devnet';
+const env = 'devnet';
 
 const main = async () => {
 	// Initialize Drift SDK
-	const sdkConfig = initialize({ env: cluster });
+	const sdkConfig = initialize({ env });
 
 	// Set up the Wallet and Provider
 	const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
@@ -74,10 +78,7 @@ const main = async () => {
 		connection,
 		wallet: provider.wallet,
 		programID: driftPublicKey,
-		perpMarketIndexes: PerpMarkets[cluster].map((market) => market.marketIndex),
-		spotMarketIndexes: SpotMarkets[cluster].map(
-			(spotMarket) => spotMarket.marketIndex
-		),
+		...getMarketsAndOraclesForSubscription(env),
 		accountSubscription: {
 			type: 'polling',
 			accountLoader: bulkAccountLoader,
@@ -85,7 +86,7 @@ const main = async () => {
 	});
 	await driftClient.subscribe();
 
-	// Set up Clearing House user client
+	// Set up user client
 	const user = new User({
 		driftClient: driftClient,
 		userAccountPublicKey: await driftClient.getUserAccountPublicKey(),
@@ -95,7 +96,7 @@ const main = async () => {
 		},
 	});
 
-	//// Check if clearing house account exists for the current wallet
+	//// Check if user account exists for the current wallet
 	const userAccountExists = await user.exists();
 
 	if (!userAccountExists) {
@@ -118,54 +119,45 @@ const main = async () => {
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
-	const currentMarketPrice = calculateReservePrice(
-		driftClient.getPerpMarketAccount(solMarketInfo.marketIndex),
-		undefined
+	const marketIndex = solMarketInfo.marketIndex;
+	const [bid, ask] = calculateBidAskPrice(
+		driftClient.getPerpMarketAccount(marketIndex).amm,
+		driftClient.getOracleDataForPerpMarket(marketIndex)
 	);
 
-	const formattedPrice = convertToNumber(currentMarketPrice, PRICE_PRECISION);
+	const formattedBidPrice = convertToNumber(bid, PRICE_PRECISION);
+	const formattedAskPrice = convertToNumber(ask, PRICE_PRECISION);
 
-	console.log(`Current Market Price is $${formattedPrice}`);
+	console.log(
+		`Current amm bid and ask price are $${formattedBidPrice} and $${formattedAskPrice}`
+	);
 
 	// Estimate the slippage for a $5000 LONG trade
 	const solMarketAccount = driftClient.getPerpMarketAccount(
 		solMarketInfo.marketIndex
 	);
 
-	const longAmount = new BN(5000).mul(QUOTE_PRECISION);
 	const slippage = convertToNumber(
 		calculateTradeSlippage(
 			PositionDirection.LONG,
-			longAmount,
+			new BN(1).mul(BASE_PRECISION),
 			solMarketAccount,
-			'quote',
-			undefined
+			'base',
+			driftClient.getOracleDataForPerpMarket(solMarketInfo.marketIndex)
 		)[0],
 		PRICE_PRECISION
 	);
 
-	console.log(
-		`Slippage for a $5000 LONG on the SOL market would be $${slippage}`
-	);
+	console.log(`Slippage for a 1 SOL-PERP would be $${slippage}`);
 
-	// Make a $5000 LONG trade
-	await driftClient.openPosition(
-		PositionDirection.LONG,
-		longAmount,
-		solMarketInfo.marketIndex
+	await driftClient.placePerpOrder(
+		getMarketOrderParams({
+			baseAssetAmount: new BN(1).mul(BASE_PRECISION),
+			direction: PositionDirection.LONG,
+			marketIndex: solMarketAccount.marketIndex,
+		})
 	);
-	console.log(`LONGED $5000 SOL`);
-
-	// Reduce the position by $2000
-	const reduceAmount = new BN(2000).mul(QUOTE_PRECISION);
-	await driftClient.openPosition(
-		PositionDirection.SHORT,
-		reduceAmount,
-		solMarketInfo.marketIndex
-	);
-
-	// Close the rest of the position
-	await driftClient.closePosition(solMarketInfo.marketIndex);
+	console.log(`Placed a 1 SOL-PERP LONG order`);
 };
 
 main();

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.11.0",
+  "version": "2.12.0-beta.1",
   "name": "drift",
   "instructions": [
     {
@@ -8568,6 +8568,11 @@
       "code": 6224,
       "name": "MaxNumberOfUsers",
       "msg": "Max Number Of Users"
+    },
+    {
+      "code": 6225,
+      "name": "InvalidOracleForSettlePnl",
+      "msg": "InvalidOracleForSettlePnl"
     }
   ]
 }

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { PerpMarketAccount, PositionDirection } from '../types';
+import { MarketType, PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -6,6 +6,7 @@ import {
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
+	BASE_PRECISION,
 } from '../constants/numericConstants';
 import {
 	calculateBidPrice,
@@ -23,6 +24,7 @@ import {
 import { squareRootBN } from './utils';
 import { isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
+import { DLOB } from '../dlob/DLOB';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -61,7 +63,7 @@ export function calculateTradeSlippage(
 	amount: BN,
 	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
-	oraclePriceData?: OraclePriceData,
+	oraclePriceData: OraclePriceData,
 	useSpread = true
 ): [BN, BN, BN, BN] {
 	let oldPrice: BN;
@@ -349,3 +351,216 @@ export function calculateTargetPriceTrade(
 		return [direction, baseSize, entryPrice, targetPrice];
 	}
 }
+
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or vamm)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param slot
+ * @param minPerpAuctionDuration
+ */
+export function calculateEstimatedPerpEntryPrice(
+	assetType: AssetType,
+	amount: BN,
+	direction: PositionDirection,
+	market: PerpMarketAccount,
+	oraclePriceData: OraclePriceData,
+	dlob: DLOB,
+	slot: number,
+	minPerpAuctionDuration: number
+): [BN, BN] {
+	if (amount.eq(ZERO)) {
+		return [ZERO, ZERO];
+	}
+
+	const takerIsLong = isVariant(direction, 'long');
+	const limitOrders = dlob[
+		takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'
+	](
+		market.marketIndex,
+		slot,
+		MarketType.PERP,
+		oraclePriceData,
+		minPerpAuctionDuration
+	);
+
+	const swapDirection = getSwapDirection(assetType, direction);
+
+	const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+		calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+	const amm = {
+		baseAssetReserve,
+		quoteAssetReserve,
+		sqrtK: sqrtK,
+		pegMultiplier: newPeg,
+	};
+
+	const invariant = amm.sqrtK.mul(amm.sqrtK);
+
+	let initialPrice = calculatePrice(
+		amm.baseAssetReserve,
+		amm.quoteAssetReserve,
+		amm.pegMultiplier
+	);
+
+	let cumulativeBaseFilled = ZERO;
+	let cumulativeQuoteFilled = ZERO;
+
+	let limitOrder = limitOrders.next().value;
+	if (limitOrder) {
+		const limitOrderPrice = limitOrder.getPrice(oraclePriceData, slot);
+		initialPrice = takerIsLong
+			? BN.min(limitOrderPrice, initialPrice)
+			: BN.max(limitOrderPrice, initialPrice);
+	}
+
+	if (assetType === 'base') {
+		while (!cumulativeBaseFilled.eq(amount)) {
+			const limitOrderPrice = limitOrder?.getPrice(oraclePriceData, slot);
+
+			let maxAmmFill: BN;
+			if (limitOrderPrice) {
+				const newBaseReserves = squareRootBN(
+					invariant
+						.mul(PRICE_PRECISION)
+						.mul(amm.pegMultiplier)
+						.div(limitOrderPrice)
+						.div(PEG_PRECISION)
+				);
+
+				// will be zero if the limit order price is better than the amm price
+				maxAmmFill = takerIsLong
+					? amm.baseAssetReserve.sub(newBaseReserves)
+					: newBaseReserves.sub(amm.baseAssetReserve);
+			} else {
+				maxAmmFill = amount.sub(cumulativeBaseFilled);
+			}
+
+			if (maxAmmFill.gt(ZERO)) {
+				const baseFilled = BN.min(amount.sub(cumulativeBaseFilled), maxAmmFill);
+				const [afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(amm, 'base', baseFilled, swapDirection);
+
+				const quoteFilled = calculateQuoteAssetAmountSwapped(
+					amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(),
+					amm.pegMultiplier,
+					swapDirection
+				);
+
+				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+				amm.baseAssetReserve = afterSwapBaseReserves;
+				amm.quoteAssetReserve = afterSwapQuoteReserves;
+
+				if (cumulativeBaseFilled.eq(amount)) {
+					break;
+				}
+			}
+
+			const baseFilled = BN.min(
+				limitOrder.order.baseAssetAmount.sub(
+					limitOrder.order.baseAssetAmountFilled
+				),
+				amount.sub(cumulativeBaseFilled)
+			);
+			const quoteFilled = baseFilled.mul(limitOrderPrice).div(BASE_PRECISION);
+
+			cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+			cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+			if (cumulativeBaseFilled.eq(amount)) {
+				break;
+			}
+
+			limitOrder = limitOrders.next().value;
+		}
+	} else {
+		while (!cumulativeQuoteFilled.eq(amount)) {
+			const limitOrderPrice = limitOrder?.getPrice(oraclePriceData, slot);
+
+			let maxAmmFill: BN;
+			if (limitOrderPrice) {
+				const newQuoteReserves = squareRootBN(
+					invariant
+						.mul(PEG_PRECISION)
+						.mul(limitOrderPrice)
+						.div(amm.pegMultiplier)
+						.div(PRICE_PRECISION)
+				);
+
+				// will be zero if the limit order price is better than the amm price
+				maxAmmFill = takerIsLong
+					? newQuoteReserves.sub(amm.quoteAssetReserve)
+					: amm.quoteAssetReserve.sub(newQuoteReserves);
+			} else {
+				maxAmmFill = amount.sub(cumulativeQuoteFilled);
+			}
+
+			if (maxAmmFill.gt(ZERO)) {
+				const quoteFilled = BN.min(
+					amount.sub(cumulativeQuoteFilled),
+					maxAmmFill
+				);
+				const [afterSwapQuoteReserves, afterSwapBaseReserves] =
+					calculateAmmReservesAfterSwap(
+						amm,
+						'quote',
+						quoteFilled,
+						swapDirection
+					);
+
+				const baseFilled = afterSwapBaseReserves
+					.sub(amm.baseAssetReserve)
+					.abs();
+
+				cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+				cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+				amm.baseAssetReserve = afterSwapBaseReserves;
+				amm.quoteAssetReserve = afterSwapQuoteReserves;
+
+				if (cumulativeQuoteFilled.eq(amount)) {
+					break;
+				}
+			}
+
+			const quoteFilled = BN.min(
+				limitOrder.order.baseAssetAmount
+					.sub(limitOrder.order.baseAssetAmountFilled)
+					.mul(limitOrderPrice)
+					.div(BASE_PRECISION),
+				amount.sub(cumulativeQuoteFilled)
+			);
+
+			const baseFilled = quoteFilled.mul(BASE_PRECISION).div(limitOrderPrice);
+
+			cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+			cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+
+			if (cumulativeQuoteFilled.eq(amount)) {
+				break;
+			}
+
+			limitOrder = limitOrders.next().value;
+		}
+	}
+
+	const entryPrice = cumulativeQuoteFilled
+		.mul(BASE_PRECISION)
+		.div(cumulativeBaseFilled);
+
+	const priceImpact = entryPrice
+		.sub(initialPrice)
+		.mul(PRICE_PRECISION)
+		.div(initialPrice)
+		.abs();
+
+	return [entryPrice, priceImpact];
+}