@drift-labs/sdk 0.1.31 → 0.1.34-master.0

package/src/idl/clearing_house.json

@@ -1905,6 +1905,36 @@
         }
       ]
     },
+    {
+      "name": "updateMarketBaseSpread",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "markets",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "marketIndex",
+          "type": "u64"
+        },
+        {
+          "name": "baseSpread",
+          "type": "u16"
+        }
+      ]
+    },
     {
       "name": "updateMarketMinimumBaseAssetTradeSize",
       "accounts": [
@@ -3265,9 +3295,17 @@
             "name": "minimumBaseAssetTradeSize",
             "type": "u128"
           },
+          {
+            "name": "baseSpread",
+            "type": "u16"
+          },
+          {
+            "name": "padding0",
+            "type": "u16"
+          },
           {
             "name": "padding1",
-            "type": "u64"
+            "type": "u32"
           },
           {
             "name": "padding2",
@@ -3585,7 +3623,7 @@
             "type": "u128"
           },
           {
-            "name": "referrerReward",
+            "name": "quoteAssetAmountSurplus",
             "type": "u128"
           },
           {

package/src/math/amm.ts

@@ -7,6 +7,8 @@ import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	QUOTE_PRECISION,
 	AMM_RESERVE_PRECISION,
+	BID_ASK_SPREAD_PRECISION,
+	ONE,
 } from '../constants/numericConstants';
 import { calculateBaseAssetValue } from './position';
 import {
@@ -60,7 +62,10 @@ export type AssetType = 'quote' | 'base';
  * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
  */
 export function calculateAmmReservesAfterSwap(
-	amm: AMM,
+	amm: Pick<
+		AMM,
+		'pegMultiplier' | 'quoteAssetReserve' | 'sqrtK' | 'baseAssetReserve'
+	>,
 	inputAssetType: AssetType,
 	swapAmount: BN,
 	swapDirection: SwapDirection
@@ -93,6 +98,38 @@ export function calculateAmmReservesAfterSwap(
 	return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 
+export function calculateSpreadReserves(
+	amm: AMM,
+	direction: PositionDirection
+): {
+	baseAssetReserve: BN;
+	quoteAssetReserve: BN;
+} {
+	if (amm.baseSpread === 0) {
+		return {
+			baseAssetReserve: amm.baseAssetReserve,
+			quoteAssetReserve: amm.quoteAssetReserve,
+		};
+	}
+
+	const quoteAsserReserveDelta = amm.quoteAssetReserve.div(
+		BID_ASK_SPREAD_PRECISION.div(new BN(amm.baseSpread / 4))
+	);
+
+	let quoteAssetReserve;
+	if (isVariant(direction, 'long')) {
+		quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
+	} else {
+		quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
+	}
+
+	const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
+	return {
+		baseAssetReserve,
+		quoteAssetReserve,
+	};
+}
+
 /**
  * Helper function calculating constant product curve output. Agnostic to whether input asset is quote or base
  *
@@ -288,7 +325,9 @@ export function calculateTerminalPrice(market: Market) {
 
 export function calculateMaxBaseAssetAmountToTrade(
 	amm: AMM,
-	limit_price: BN
+	limit_price: BN,
+	direction: PositionDirection,
+	useSpread: boolean
 ): [BN, PositionDirection] {
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
 
@@ -300,14 +339,24 @@ export function calculateMaxBaseAssetAmountToTrade(
 
 	const newBaseAssetReserve = squareRootBN(newBaseAssetReserveSquared);
 
-	if (newBaseAssetReserve.gt(amm.baseAssetReserve)) {
+	let baseAssetReserveBefore;
+	if (useSpread) {
+		baseAssetReserveBefore = calculateSpreadReserves(
+			amm,
+			direction
+		).baseAssetReserve;
+	} else {
+		baseAssetReserveBefore = amm.baseAssetReserve;
+	}
+
+	if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
 		return [
-			newBaseAssetReserve.sub(amm.baseAssetReserve),
+			newBaseAssetReserve.sub(baseAssetReserveBefore),
 			PositionDirection.SHORT,
 		];
-	} else if (newBaseAssetReserve.lt(amm.baseAssetReserve)) {
+	} else if (newBaseAssetReserve.lt(baseAssetReserveBefore)) {
 		return [
-			amm.baseAssetReserve.sub(newBaseAssetReserve),
+			baseAssetReserveBefore.sub(newBaseAssetReserve),
 			PositionDirection.LONG,
 		];
 	} else {
@@ -398,3 +447,19 @@ export function calculateBudgetedPeg(market: Market, cost: BN): BN {
 
 	return newPeg;
 }
+
+export function calculateQuoteAssetAmountSwapped(
+	quoteAssetReserves: BN,
+	pegMultiplier: BN,
+	swapDirection: SwapDirection
+): BN {
+	let quoteAssetAmount = quoteAssetReserves
+		.mul(pegMultiplier)
+		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+
+	if (isVariant(swapDirection, 'remove')) {
+		quoteAssetAmount = quoteAssetAmount.add(ONE);
+	}
+
+	return quoteAssetAmount;
+}

package/src/math/funding.ts

@@ -45,7 +45,7 @@ export async function calculateAllEstimatedFundingRate(
 	const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
 	const markTwapTimeSinceLastUpdate = BN.max(
 		secondsInHour,
-		secondsInHour.sub(timeSinceLastMarkChange)
+		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
 	const baseAssetPriceWithMantissa = calculateMarkPrice(market);
 
@@ -59,6 +59,11 @@ export async function calculateAllEstimatedFundingRate(
 	const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
 	const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
 
+	const oracleInvalidDuration = BN.max(
+		ZERO,
+		lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs)
+	);
+
 	const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
 	const oracleTwapTimeSinceLastUpdate = BN.max(
 		secondsInHour,
@@ -80,7 +85,12 @@ export async function calculateAllEstimatedFundingRate(
 		oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
 			.mul(lastOracleTwapWithMantissa)
 			.add(timeSinceLastMarkChange.mul(oraclePrice))
-			.div(timeSinceLastOracleTwapUpdate.add(oracleTwapTimeSinceLastUpdate));
+			.add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
+			.div(
+				timeSinceLastMarkChange
+					.add(oracleTwapTimeSinceLastUpdate)
+					.add(oracleInvalidDuration)
+			);
 	}
 
 	const twapSpread = lastMarkTwapWithMantissa.sub(lastOracleTwapWithMantissa);

package/src/math/market.ts

@@ -3,6 +3,7 @@ import { Market, PositionDirection } from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
+	calculateSpreadReserves,
 	getSwapDirection,
 } from './amm';
 import { OraclePriceData } from '../oracles/types';
@@ -21,6 +22,44 @@ export function calculateMarkPrice(market: Market): BN {
 	);
 }
 
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+export function calculateBidPrice(market: Market): BN {
+	const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
+		market.amm,
+		PositionDirection.SHORT
+	);
+
+	return calculatePrice(
+		baseAssetReserve,
+		quoteAssetReserve,
+		market.amm.pegMultiplier
+	);
+}
+
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+export function calculateAskPrice(market: Market): BN {
+	const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
+		market.amm,
+		PositionDirection.LONG
+	);
+
+	return calculatePrice(
+		baseAssetReserve,
+		quoteAssetReserve,
+		market.amm.pegMultiplier
+	);
+}
+
 export function calculateNewMarketAfterTrade(
 	baseAssetAmount: BN,
 	direction: PositionDirection,
@@ -48,5 +87,12 @@ export function calculateMarkOracleSpread(
 	oraclePriceData: OraclePriceData
 ): BN {
 	const markPrice = calculateMarkPrice(market);
-	return markPrice.sub(oraclePriceData.price);
+	return calculateOracleSpread(markPrice, oraclePriceData);
+}
+
+export function calculateOracleSpread(
+	price: BN,
+	oraclePriceData: OraclePriceData
+): BN {
+	return price.sub(oraclePriceData.price);
 }

package/src/math/orders.ts

@@ -89,17 +89,20 @@ export function isOrderReduceOnly(
 		user.getEmptyPosition(order.marketIndex);
 
 	// if position is long and order is long
-	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+	if (
+		position.baseAssetAmount.gte(ZERO) &&
+		isVariant(order.direction, 'long')
+	) {
 		return false;
 	}
 
 	// if position is short and order is short
 	if (
-		position.baseAssetAmount.lt(ZERO) &&
+		position.baseAssetAmount.lte(ZERO) &&
 		isVariant(order.direction, 'short')
 	) {
 		return false;
 	}
 
-	return order.baseAssetAmount.abs().lte(position.baseAssetAmount.abs());
+	return true;
 }

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { isVariant, Market, PositionDirection } from '../types';
+import { Market, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -6,7 +6,6 @@ import {
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
-	ONE,
 } from '../constants/numericConstants';
 import { calculateMarkPrice } from './market';
 import {
@@ -14,6 +13,7 @@ import {
 	calculatePrice,
 	getSwapDirection,
 	AssetType,
+	calculateSpreadReserves,
 } from './amm';
 import { squareRootBN } from './utils';
 
@@ -101,6 +101,8 @@ export function calculateTradeSlippage(
  * @param direction
  * @param amount
  * @param market
+ * @param inputAssetType
+ * @param useSpread
  * @return
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
@@ -109,27 +111,36 @@ export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
 	market: Market,
-	inputAssetType: AssetType = 'quote'
+	inputAssetType: AssetType = 'quote',
+	useSpread = true
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO];
 	}
 
 	const swapDirection = getSwapDirection(inputAssetType, direction);
-	const [newQuoteAssetReserve, newBaseAssetReserve] =
-		calculateAmmReservesAfterSwap(
+
+	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
 			market.amm,
-			inputAssetType,
-			amount,
-			swapDirection
+			direction
 		);
-
-	const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
-	let acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	if (inputAssetType === 'base' && isVariant(swapDirection, 'remove')) {
-		acquiredQuote = acquiredQuote.sub(ONE);
+		amm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: market.amm.sqrtK,
+			pegMultiplier: market.amm.pegMultiplier,
+		};
+	} else {
+		amm = market.amm;
 	}
 
+	const [newQuoteAssetReserve, newBaseAssetReserve] =
+		calculateAmmReservesAfterSwap(amm, inputAssetType, amount, swapDirection);
+
+	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
+	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
 	return [acquiredBase, acquiredQuote];
 }
 

package/src/orders.ts

@@ -11,6 +11,7 @@ import {
 	BN,
 	calculateAmmReservesAfterSwap,
 	calculateBaseAssetValue,
+	calculateSpreadReserves,
 	ClearingHouseUser,
 	isOrderRiskIncreasingInSameDirection,
 	TEN_THOUSAND,
@@ -211,7 +212,9 @@ export function calculateAmountToTradeForLimit(
 
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
 		market.amm,
-		limitPrice
+		limitPrice,
+		order.direction,
+		!order.postOnly
 	);
 
 	// Check that directions are the same
@@ -295,15 +298,56 @@ export function calculateBaseAssetAmountUserCanExecute(
 		return ZERO;
 	}
 
-	const baseAssetReservesBefore = market.amm.baseAssetReserve;
+	const swapDirection = isVariant(order.direction, 'long')
+		? SwapDirection.ADD
+		: SwapDirection.REMOVE;
+
+	const useSpread = !order.postOnly;
+	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+	if (useSpread) {
+		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
+			market.amm,
+			order.direction
+		);
+		amm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: market.amm.sqrtK,
+			pegMultiplier: market.amm.pegMultiplier,
+		};
+	} else {
+		amm = market.amm;
+	}
+
+	const baseAssetReservesBefore = amm.baseAssetReserve;
 	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
-		market.amm,
+		amm,
 		'quote',
 		quoteAssetAmount,
-		isVariant(order.direction, 'long')
-			? SwapDirection.ADD
-			: SwapDirection.REMOVE
+		swapDirection
 	);
 
-	return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+	let baseAssetAmount = baseAssetReservesBefore
+		.sub(baseAssetReservesAfter)
+		.abs();
+	if (order.reduceOnly) {
+		const position =
+			user.getUserPosition(order.marketIndex) ||
+			user.getEmptyPosition(order.marketIndex);
+		if (
+			isVariant(order.direction, 'long') &&
+			position.baseAssetAmount.gte(ZERO)
+		) {
+			baseAssetAmount = ZERO;
+		} else if (
+			isVariant(order.direction, 'short') &&
+			position.baseAssetAmount.lte(ZERO)
+		) {
+			baseAssetAmount = ZERO;
+		} else {
+			BN.min(baseAssetAmount, position.baseAssetAmount.abs());
+		}
+	}
+
+	return baseAssetAmount;
 }

package/src/tx/retryTxSender.ts

@@ -227,4 +227,16 @@ export class RetryTxSender implements TxSender {
 			});
 		});
 	}
+
+	public addAdditionalConnection(newConnection: Connection): void {
+		const alreadyUsingConnection =
+			this.additionalConnections.filter((connection) => {
+				// @ts-ignore
+				return connection._rpcEndpoint === newConnection.rpcEndpoint;
+			}).length > 0;
+
+		if (!alreadyUsingConnection) {
+			this.additionalConnections.push(newConnection);
+		}
+	}
 }

package/src/types.ts

@@ -154,7 +154,7 @@ export type TradeRecord = {
 	markPriceBefore: BN;
 	markPriceAfter: BN;
 	fee: BN;
-	referrerReward: BN;
+	quoteAssetAmountSurplus: BN;
 	refereeDiscount: BN;
 	tokenDiscount: BN;
 	marketIndex: BN;
@@ -309,6 +309,7 @@ export type AMM = {
 	minimumQuoteAssetTradeSize: BN;
 	minimumBaseAssetTradeSize: BN;
 	lastOraclePrice: BN;
+	baseSpread: number;
 };
 
 // # User Account Types

package/src/assert/assert.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
-function assert(condition, error) {
-    if (!condition) {
-        throw new Error(error || 'Unspecified AssertionError');
-    }
-}
-exports.assert = assert;
-//# sourceMappingURL=assert.js.map

package/src/assert/assert.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert.js","sourceRoot":"","sources":["assert.ts"],"names":[],"mappings":";;;AAAA,SAAgB,MAAM,CAAC,SAAkB,EAAE,KAAc;IACxD,IAAI,CAAC,SAAS,EAAE;QACf,MAAM,IAAI,KAAK,CAAC,KAAK,IAAI,4BAA4B,CAAC,CAAC;KACvD;AACF,CAAC;AAJD,wBAIC"}

package/src/math/conversion.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertBaseAssetAmountToNumber = exports.convertToNumber = void 0;
-const numericConstants_1 = require("../constants/numericConstants");
-const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PRECISION) => {
-    if (!bigNumber)
-        return 0;
-    return (bigNumber.div(precision).toNumber() +
-        bigNumber.mod(precision).toNumber() / precision.toNumber());
-};
-exports.convertToNumber = convertToNumber;
-const convertBaseAssetAmountToNumber = (baseAssetAmount) => {
-    return (0, exports.convertToNumber)(baseAssetAmount, numericConstants_1.MARK_PRICE_PRECISION.mul(numericConstants_1.PEG_PRECISION));
-};
-exports.convertBaseAssetAmountToNumber = convertBaseAssetAmountToNumber;
-//# sourceMappingURL=conversion.js.map

package/src/math/conversion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"conversion.js","sourceRoot":"","sources":["conversion.ts"],"names":[],"mappings":";;;AACA,oEAGuC;AAEhC,MAAM,eAAe,GAAG,CAC9B,SAAa,EACb,YAAgB,uCAAoB,EACnC,EAAE;IACH,IAAI,CAAC,SAAS;QAAE,OAAO,CAAC,CAAC;IACzB,OAAO,CACN,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE;QACnC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,GAAG,SAAS,CAAC,QAAQ,EAAE,CAC1D,CAAC;AACH,CAAC,CAAC;AATW,QAAA,eAAe,mBAS1B;AAEK,MAAM,8BAA8B,GAAG,CAAC,eAAmB,EAAE,EAAE;IACrE,OAAO,IAAA,uBAAe,EACrB,eAAe,EACf,uCAAoB,CAAC,GAAG,CAAC,gCAAa,CAAC,CACvC,CAAC;AACH,CAAC,CAAC;AALW,QAAA,8BAA8B,kCAKzC"}