@drift-labs/sdk 0.1.27 → 0.1.29-master.1

package/src/clearingHouse.ts

@@ -788,6 +788,46 @@ export class ClearingHouse {
 		});
 	}
 
+	public async expireOrders(
+		userAccountPublicKey: PublicKey,
+		userOrdersAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(
+				await this.getExpireOrdersIx(
+					userAccountPublicKey,
+					userOrdersAccountPublicKey
+				)
+			),
+			[],
+			this.opts
+		);
+	}
+
+	public async getExpireOrdersIx(
+		userAccountPublicKey: PublicKey,
+		userOrdersAccountPublicKey: PublicKey
+	): Promise<TransactionInstruction> {
+		const fillerPublicKey = await this.getUserAccountPublicKey();
+		const userAccount: any = await this.program.account.user.fetch(
+			userAccountPublicKey
+		);
+
+		const orderState = this.getOrderStateAccount();
+		return await this.program.instruction.expireOrders({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				filler: fillerPublicKey,
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				userPositions: userAccount.positions,
+				userOrders: userOrdersAccountPublicKey,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+			},
+		});
+	}
+
 	public async cancelOrder(
 		orderId: BN,
 		oracle?: PublicKey

package/src/constants/markets.ts

@@ -166,7 +166,7 @@ export const Markets: MarketConfig[] = [
 		oracleSource: OracleSource.SWITCHBOARD,
 	},
 	{
-		fullName: 'Ape',
+		fullName: 'ApeCoin',
 		category: ['NFT'],
 		symbol: 'APE-PERP',
 		baseAssetSymbol: 'APE',
@@ -176,6 +176,17 @@ export const Markets: MarketConfig[] = [
 		launchTs: 1648475932000,
 		oracleSource: OracleSource.SWITCHBOARD,
 	},
+	{
+		fullName: 'DogeCoin',
+		category: ['Meme', 'NFT'],
+		symbol: 'DOGE-PERP',
+		baseAssetSymbol: 'DOGE',
+		marketIndex: new BN(15),
+		devnetPublicKey: '4L6YhY8VvUgmqG5MvJkUJATtzB2rFqdrJwQCmFLv4Jzy',
+		mainnetPublicKey: 'FsSM3s38PX9K7Dn6eGzuE29S2Dsk1Sss1baytTQdCaQj',
+		launchTs: 1648607439000,
+		oracleSource: OracleSource.PYTH,
+	},
 	// {
 	// 	symbol: 'mSOL-PERP',
 	// 	baseAssetSymbol: 'mSOL',

package/src/idl/clearing_house.json

@@ -677,6 +677,52 @@
         }
       ]
     },
+    {
+      "name": "expireOrders",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "orderState",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "filler",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userPositions",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userOrders",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "orderHistory",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
     {
       "name": "fillOrder",
       "accounts": [
@@ -1398,6 +1444,11 @@
           "isMut": true,
           "isSigner": false
         },
+        {
+          "name": "userOrders",
+          "isMut": true,
+          "isSigner": false
+        },
         {
           "name": "authority",
           "isMut": false,
@@ -3190,8 +3241,8 @@
             "type": "u128"
           },
           {
-            "name": "padding1",
-            "type": "u64"
+            "name": "netRevenueSinceLastFunding",
+            "type": "i64"
           },
           {
             "name": "padding2",
@@ -3800,6 +3851,9 @@
           },
           {
             "name": "Fill"
+          },
+          {
+            "name": "Expire"
           }
         ]
       }
@@ -4190,6 +4244,16 @@
       "code": 6059,
       "name": "InvalidOracleOffset",
       "msg": "InvalidOracleOffset"
+    },
+    {
+      "code": 6060,
+      "name": "CantExpireOrders",
+      "msg": "CantExpireOrders"
+    },
+    {
+      "code": 6061,
+      "name": "InvalidRepegPriceImpact",
+      "msg": "AMM repeg mark price impact vs oracle too large"
     }
   ]
 }

package/src/math/amm.ts

@@ -2,13 +2,12 @@ import { BN } from '@project-serum/anchor';
 import {
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
 	MARK_PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	QUOTE_PRECISION,
-	AMM_RESERVE_PRECISION,
 } from '../constants/numericConstants';
-import { calculateBaseAssetValue } from './position';
 import {
 	AMM,
 	PositionDirection,
@@ -17,12 +16,7 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import {
-	calculatePositionPNL,
-	calculateMarkPrice,
-	convertToNumber,
-	squareRootBN,
-} from '..';
+import { squareRootBN } from '..';
 
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
@@ -139,125 +133,6 @@ export function getSwapDirection(
 	return SwapDirection.ADD;
 }
 
-/**
- * Helper function calculating adjust k cost
- * @param market
- * @param marketIndex
- * @param numerator
- * @param denomenator
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export function calculateAdjustKCost(
-	market: Market,
-	marketIndex: BN,
-	numerator: BN,
-	denomenator: BN
-): BN {
-	const netUserPosition = {
-		baseAssetAmount: market.baseAssetAmount,
-		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-		marketIndex: new BN(marketIndex),
-		quoteAssetAmount: new BN(0),
-		openOrders: new BN(0),
-	};
-
-	const currentValue = calculateBaseAssetValue(market, netUserPosition);
-
-	const marketNewK = Object.assign({}, market);
-	marketNewK.amm = Object.assign({}, market.amm);
-
-	marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
-		.mul(numerator)
-		.div(denomenator);
-	marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
-		.mul(numerator)
-		.div(denomenator);
-	marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
-
-	netUserPosition.quoteAssetAmount = currentValue;
-
-	const cost = calculatePositionPNL(marketNewK, netUserPosition);
-
-	const p = PEG_PRECISION.mul(numerator).div(denomenator);
-	const x = market.amm.baseAssetReserve;
-	const y = market.amm.quoteAssetReserve;
-	const delta = market.baseAssetAmount;
-	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-
-	const numer1 = PEG_PRECISION.sub(p).mul(y).div(PEG_PRECISION);
-	const numer20 = k
-		.mul(p)
-		.mul(p)
-		.div(PEG_PRECISION)
-		.div(PEG_PRECISION)
-		.div(x.mul(p).div(PEG_PRECISION).add(delta));
-	const numer21 = k.div(x.add(delta));
-
-	const formulaCost = numer21
-		.sub(numer20)
-		.sub(numer1)
-		.mul(market.amm.pegMultiplier)
-		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-	console.log(convertToNumber(formulaCost, QUOTE_PRECISION));
-
-	// p.div(p.mul(x).add(delta)).sub()
-
-	return cost;
-}
-
-/**
- * Helper function calculating adjust pegMultiplier (repeg) cost
- *
- * @param market
- * @param marketIndex
- * @param newPeg
- * @returns cost : Precision QUOTE_ASSET_PRECISION
- */
-export function calculateRepegCost(
-	market: Market,
-	marketIndex: BN,
-	newPeg: BN
-): BN {
-	const netUserPosition = {
-		baseAssetAmount: market.baseAssetAmount,
-		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
-		marketIndex: new BN(marketIndex),
-		quoteAssetAmount: new BN(0),
-		openOrders: new BN(0),
-	};
-
-	const currentValue = calculateBaseAssetValue(market, netUserPosition);
-	netUserPosition.quoteAssetAmount = currentValue;
-	const prevMarketPrice = calculateMarkPrice(market);
-	const marketNewPeg = Object.assign({}, market);
-	marketNewPeg.amm = Object.assign({}, market.amm);
-
-	// const marketNewPeg = JSON.parse(JSON.stringify(market));
-	marketNewPeg.amm.pegMultiplier = newPeg;
-
-	console.log(
-		'Price moves from',
-		convertToNumber(prevMarketPrice),
-		'to',
-		convertToNumber(calculateMarkPrice(marketNewPeg))
-	);
-
-	const cost = calculatePositionPNL(marketNewPeg, netUserPosition);
-
-	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-	const newQuoteAssetReserve = k.div(
-		market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount)
-	);
-	const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(
-		market.amm.quoteAssetReserve
-	);
-	const cost2 = deltaQuoteAssetReserves
-		.mul(market.amm.pegMultiplier.sub(newPeg))
-		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-	console.log(convertToNumber(cost2, QUOTE_PRECISION));
-	return cost;
-}
-
 /**
  * Helper function calculating terminal price of amm
  *

package/src/math/repeg.ts

@@ -0,0 +1,253 @@
+import { BN } from '@project-serum/anchor';
+import {
+	MARK_PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
+	PEG_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { calculateBaseAssetValue } from './position';
+import { calculateTerminalPrice } from './amm';
+
+import { Market } from '../types';
+import { calculatePositionPNL, calculateMarkPrice, convertToNumber } from '..';
+
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	market: Market,
+	marketIndex: BN,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: ZERO,
+		openOrders: ZERO,
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+
+	const marketNewK = Object.assign({}, market);
+	marketNewK.amm = Object.assign({}, market.amm);
+
+	marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
+		.mul(numerator)
+		.div(denomenator);
+	marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
+		.mul(numerator)
+		.div(denomenator);
+	marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
+
+	netUserPosition.quoteAssetAmount = currentValue;
+
+	const cost = calculatePositionPNL(marketNewK, netUserPosition);
+
+	return cost;
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(
+	market: Market,
+	marketIndex: BN,
+	newPeg: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+		openOrders: ZERO,
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+	netUserPosition.quoteAssetAmount = currentValue;
+	const prevMarketPrice = calculateMarkPrice(market);
+	const marketNewPeg = Object.assign({}, market);
+	marketNewPeg.amm = Object.assign({}, market.amm);
+
+	// const marketNewPeg = JSON.parse(JSON.stringify(market));
+	marketNewPeg.amm.pegMultiplier = newPeg;
+
+	console.log(
+		'Price moves from',
+		convertToNumber(prevMarketPrice),
+		'to',
+		convertToNumber(calculateMarkPrice(marketNewPeg))
+	);
+
+	const cost = calculatePositionPNL(marketNewPeg, netUserPosition);
+
+	return cost;
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateReserveRebalanceCost(
+	market: Market,
+	marketIndex: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+		openOrders: ZERO,
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+	netUserPosition.quoteAssetAmount = currentValue;
+	const prevMarketPrice = calculateMarkPrice(market);
+	const marketNewPeg = Object.assign({}, market);
+	marketNewPeg.amm = Object.assign({}, market.amm);
+
+	// const marketNewPeg = JSON.parse(JSON.stringify(market));
+	const newPeg = calculateTerminalPrice(market)
+		.mul(PEG_PRECISION)
+		.div(MARK_PRICE_PRECISION);
+	// const newPeg = prevMarketPrice.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION);
+
+	const newBaseReserve = market.amm.baseAssetReserve.add(
+		market.baseAssetAmount
+	);
+	const newQuoteReserve = market.amm.sqrtK
+		.mul(market.amm.sqrtK)
+		.div(newBaseReserve);
+	console.log(
+		'current reserves on close, quote:',
+		convertToNumber(newQuoteReserve, AMM_RESERVE_PRECISION),
+		'base:',
+		convertToNumber(newBaseReserve, AMM_RESERVE_PRECISION)
+	);
+
+	let newSqrtK;
+	if (newPeg.lt(market.amm.pegMultiplier)) {
+		newSqrtK = newBaseReserve;
+	} else {
+		newSqrtK = newQuoteReserve;
+	}
+
+	marketNewPeg.amm.baseAssetReserve = newSqrtK.sub(market.baseAssetAmount); // newSqrtK.sub(market.baseAssetAmount);
+	marketNewPeg.amm.quoteAssetReserve = newSqrtK
+		.mul(newSqrtK)
+		.div(marketNewPeg.amm.baseAssetReserve);
+	marketNewPeg.amm.sqrtK = newSqrtK;
+	marketNewPeg.amm.pegMultiplier = newPeg;
+
+	console.log(
+		'Price moves from',
+		convertToNumber(prevMarketPrice),
+		'to',
+		convertToNumber(calculateMarkPrice(marketNewPeg))
+	);
+
+	const cost = calculatePositionPNL(marketNewPeg, netUserPosition);
+
+	return cost;
+}
+
+export function calculateBudgetedK(market: Market, cost: BN): [BN, BN] {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+
+	const d = market.baseAssetAmount;
+	const Q = market.amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const numer1 = y.mul(d).mul(Q).div(AMM_RESERVE_PRECISION).div(PEG_PRECISION);
+	const numer2 = C.mul(x.add(d)).div(QUOTE_PRECISION);
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numerator = d
+		.mul(numer1.add(numer2))
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1
+		.add(denom2)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	console.log(numerator, denominator);
+	// const p = (numerator).div(denominator);
+
+	// const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+	// console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedPeg(market: Market, cost: BN): BN {
+	// wolframalpha.com
+	// (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+	// p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = market.amm.baseAssetReserve;
+	const y = market.amm.quoteAssetReserve;
+
+	const d = market.baseAssetAmount;
+	const Q = market.amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION).div(
+		deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO)
+	);
+	// .mul(PEG_PRECISION)
+	// .div(QUOTE_PRECISION);
+	console.log(
+		Q.toNumber(),
+		'change by',
+		deltaPegMultiplier.toNumber() / MARK_PRICE_PRECISION.toNumber()
+	);
+	const newPeg = Q.sub(
+		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+	);
+
+	return newPeg;
+}

package/src/types.ts

@@ -40,6 +40,7 @@ export class OrderDiscountTier {
 export class OrderAction {
 	static readonly PLACE = { place: {} };
 	static readonly CANCEL = { cancel: {} };
+	static readonly EXPIRE = { expire: {} };
 	static readonly FILL = { fill: {} };
 }