@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.2

package/src/math/repeg.ts

@@ -0,0 +1,176 @@
+import { BN } from '@project-serum/anchor';
+import { assert } from '../assert/assert';
+import {
+	MARK_PRICE_PRECISION,
+	AMM_RESERVE_PRECISION,
+	PEG_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	PRICE_DIV_PEG,
+	QUOTE_PRECISION,
+	ZERO,
+} from '../constants/numericConstants';
+import { AMM } from '../types';
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	amm: AMM,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.netBaseAssetAmount;
+	const Q = amm.pegMultiplier;
+
+	const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
+
+	const p = numerator.mul(MARK_PRICE_PRECISION).div(denomenator);
+
+	const cost = quoteScale
+		.div(x.add(d))
+		.sub(
+			quoteScale
+				.mul(p)
+				.div(MARK_PRICE_PRECISION)
+				.div(x.mul(p).div(MARK_PRICE_PRECISION).add(d))
+		)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(PEG_PRECISION);
+
+	return cost.mul(new BN(-1));
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(amm: AMM, newPeg: BN): BN {
+	const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+	const cost = dqar
+		.mul(newPeg.sub(amm.pegMultiplier))
+		.div(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(PEG_PRECISION);
+	return cost;
+}
+
+export function calculateBudgetedKBN(
+	x: BN,
+	y: BN,
+	budget: BN,
+	Q: BN,
+	d: BN
+): [BN, BN] {
+	assert(Q.gt(new BN(0)));
+	const C = budget.mul(new BN(-1));
+
+	let dSign = new BN(1);
+	if (d.lt(new BN(0))) {
+		dSign = new BN(-1);
+	}
+	const pegged_y_d_d = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numer1 = pegged_y_d_d;
+	const numer2 = C.mul(d)
+		.div(QUOTE_PRECISION)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.mul(dSign);
+
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = pegged_y_d_d;
+
+	const numerator = numer1.sub(numer2).div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1.add(denom2).div(AMM_TO_QUOTE_PRECISION_RATIO);
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedK(amm: AMM, 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*d*d*Q)
+
+	// numer
+	//   =  y*d*d*Q - Cxd - Cdd
+	//   =  y/x*Q*d*d - Cd - Cd/x
+	//   = mark      - C/d - C/(x)
+	//   =  mark/C    - 1/d - 1/x
+
+	// denom
+	// = C*x*x + C*x*d + y*d*d*Q
+	// = x/d**2 + 1 / d + mark/C
+
+	// todo: assumes k = x * y
+	// otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.netBaseAssetAmount;
+	const Q = amm.pegMultiplier;
+
+	const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+
+	return [numerator, denominator];
+}
+
+export function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: 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 targetPeg = targetPrice
+		.mul(amm.baseAssetReserve)
+		.div(amm.quoteAssetReserve)
+		.div(PRICE_DIV_PEG);
+
+	const k = amm.sqrtK.mul(amm.sqrtK);
+	const x = amm.baseAssetReserve;
+	const y = amm.quoteAssetReserve;
+
+	const d = amm.netBaseAssetAmount;
+	const Q = amm.pegMultiplier;
+
+	const C = cost.mul(new BN(-1));
+
+	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+	const pegChangeDirection = targetPeg.sub(Q);
+
+	const useTargetPeg =
+		(deltaQuoteAssetReserves.lt(ZERO) && pegChangeDirection.gt(ZERO)) ||
+		(deltaQuoteAssetReserves.gt(ZERO) && pegChangeDirection.lt(ZERO));
+
+	if (deltaQuoteAssetReserves.eq(ZERO) || useTargetPeg) {
+		return targetPeg;
+	}
+
+	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION).div(
+		deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO)
+	);
+	const newPeg = Q.sub(
+		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+	);
+
+	return newPeg;
+}

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection, SwapDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -17,10 +17,12 @@ import {
 	calculatePrice,
 	getSwapDirection,
 	AssetType,
-	calculateSpreadReserves,
+	calculateUpdatedAMMSpreadReserves,
+	calculateQuoteAssetAmountSwapped,
 } from './amm';
 import { squareRootBN } from './utils';
 import { isVariant } from '../types';
+import { OraclePriceData } from '../oracles/types';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -57,20 +59,21 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	inputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
 	useSpread = true
 ): [BN, BN, BN, BN] {
 	let oldPrice: BN;
 
 	if (useSpread && market.amm.baseSpread > 0) {
 		if (isVariant(direction, 'long')) {
-			oldPrice = calculateAskPrice(market);
+			oldPrice = calculateAskPrice(market, oraclePriceData);
 		} else {
-			oldPrice = calculateBidPrice(market);
+			oldPrice = calculateBidPrice(market, oraclePriceData);
 		}
 	} else {
-		oldPrice = calculateMarkPrice(market);
+		oldPrice = calculateMarkPrice(market, oraclePriceData);
 	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
@@ -80,26 +83,33 @@ export function calculateTradeSlippage(
 		amount,
 		market,
 		inputAssetType,
+		oraclePriceData,
 		useSpread
 	);
 
-	const entryPrice = calculatePrice(
-		acquiredBase,
-		acquiredQuote,
-		market.amm.pegMultiplier
-	).mul(new BN(-1));
+	const swapDirection = isVariant(direction, 'long')
+		? SwapDirection.REMOVE
+		: SwapDirection.ADD;
+	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		market.amm.pegMultiplier,
+		swapDirection
+	);
+
+	const entryPrice = quoteAssetAmountAcquired
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.mul(MARK_PRICE_PRECISION)
+		.div(acquiredBase.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
@@ -112,9 +122,9 @@ export function calculateTradeSlippage(
 	);
 
 	if (direction == PositionDirection.SHORT) {
-		assert(newPrice.lt(oldPrice));
+		assert(newPrice.lte(oldPrice));
 	} else {
-		assert(oldPrice.lt(newPrice));
+		assert(oldPrice.lte(newPrice));
 	}
 
 	const pctMaxSlippage = newPrice
@@ -145,8 +155,9 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	inputAssetType: AssetType = 'quote',
+	oraclePriceData: OraclePriceData,
 	useSpread = true
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
@@ -157,15 +168,13 @@ export function calculateTradeAcquiredAmounts(
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
@@ -197,19 +206,20 @@ export function calculateTradeAcquiredAmounts(
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: Market,
+	market: MarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
 	useSpread = true
 ): [PositionDirection, BN, BN, BN] {
 	assert(market.amm.baseAssetReserve.gt(ZERO));
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateMarkPrice(market);
-	const bidPriceBefore = calculateBidPrice(market);
-	const askPriceBefore = calculateAskPrice(market);
+	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
+	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
 	let direction;
 	if (targetPrice.gt(markPriceBefore)) {
@@ -230,19 +240,19 @@ export function calculateTargetPriceTrade(
 	let baseAssetReserveBefore: BN;
 	let quoteAssetReserveBefore: BN;
 
+	let peg = market.amm.pegMultiplier;
+
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		baseAssetReserveBefore = baseAssetReserve;
 		quoteAssetReserveBefore = quoteAssetReserve;
+		peg = newPeg;
 	} else {
 		baseAssetReserveBefore = market.amm.baseAssetReserve;
 		quoteAssetReserveBefore = market.amm.quoteAssetReserve;
 	}
 
-	const peg = market.amm.pegMultiplier;
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
 	const k = invariant.mul(MARK_PRICE_PRECISION);
 

package/src/math/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootBN = void 0;
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
+    // Assuming the sqrt of n as n only
+    let x = n;
+    // The closed guess will be stored in the root
+    let root;
+    // To count the number of iterations
+    let count = 0;
+    const TWO = new __1.BN(2);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    while (count < Number.MAX_SAFE_INTEGER) {
+        count++;
+        // Calculate more closed x
+        root = x.add(n.div(x)).div(TWO);
+        // Check for closeness
+        if (x.sub(root).abs().lte(closeness))
+            break;
+        // Update root
+        x = root;
+    }
+    return root;
+};
+exports.squareRootBN = squareRootBN;
+//# sourceMappingURL=utils.js.map

package/src/math/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/oracles/oracleClientCache.ts

@@ -0,0 +1,20 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { getOracleClient } from '../factory/oracleClient';
+import { Connection } from '@solana/web3.js';
+
+export class OracleClientCache {
+	cache = new Map<string, OracleClient>();
+	public constructor() {}
+
+	public get(oracleSource: OracleSource, connection: Connection) {
+		const key = Object.keys(oracleSource)[0];
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
+
+		const client = getOracleClient(oracleSource, connection);
+		this.cache.set(key, client);
+		return client;
+	}
+}

package/src/oracles/pythClient.ts

@@ -1,21 +1,16 @@
-import { parsePriceData, PriceData } from '@pythnetwork/client';
+import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
-import { OraclePriceData } from './types';
+import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
-export class PythClient {
+export class PythClient implements OracleClient {
 	private connection: Connection;
 
 	public constructor(connection: Connection) {
 		this.connection = connection;
 	}
 
-	public async getPriceData(pricePublicKey: PublicKey): Promise<PriceData> {
-		const account = await this.connection.getAccountInfo(pricePublicKey);
-		return parsePriceData(account.data);
-	}
-
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
@@ -23,9 +18,7 @@ export class PythClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
 		const priceData = parsePriceData(buffer);
 		return {
 			price: convertPythPrice(priceData.aggregate.price, priceData.exponent),

package/src/oracles/quoteAssetOracleClient.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@project-serum/anchor';
+import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+
+export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
+	price: MARK_PRICE_PRECISION,
+	slot: new BN(0),
+	confidence: new BN(1),
+	hasSufficientNumberOfDataPoints: true,
+};
+
+export class QuoteAssetOracleClient implements OracleClient {
+	public constructor() {}
+
+	public async getOraclePriceData(
+		_pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		return Promise.resolve(QUOTE_ORACLE_PRICE_DATA);
+	}
+
+	public getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData {
+		return QUOTE_ORACLE_PRICE_DATA;
+	}
+}

package/src/oracles/switchboardClient.ts

@@ -1,25 +1,18 @@
-import {
-	getSwitchboardPid,
-	SwitchboardDecimal,
-} from '@switchboard-xyz/switchboard-v2';
+import { SwitchboardDecimal } from '@switchboard-xyz/switchboard-v2';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
-import { DriftEnv } from '../config';
 import { BN, Program, Idl, AnchorProvider } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 import { OracleClient, OraclePriceData } from './types';
 import { Wallet } from '../wallet';
 import switchboardV2Idl from '../idl/switchboard_v2.json';
 
-// cache switchboard program for every client object since itll always be the same
-const programMap = new Map<string, Program>();
+let program: Program | undefined;
 
 export class SwitchboardClient implements OracleClient {
 	connection: Connection;
-	env: DriftEnv;
 
-	public constructor(connection: Connection, env: DriftEnv) {
+	public constructor(connection: Connection) {
 		this.connection = connection;
-		this.env = env;
 	}
 
 	public async getOraclePriceData(
@@ -29,10 +22,8 @@ export class SwitchboardClient implements OracleClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
-		const program = await this.getProgram();
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
+		const program = this.getProgram();
 
 		const aggregatorAccountData =
 			program.account.aggregatorAccountData.coder.accounts.decode(
@@ -61,23 +52,19 @@ export class SwitchboardClient implements OracleClient {
 		};
 	}
 
-	public async getProgram(): Promise<Program> {
-		if (programMap.has(this.env)) {
-			return programMap.get(this.env);
+	public getProgram(): Program {
+		if (program) {
+			return program;
 		}
 
-		const program = await getSwitchboardProgram(this.env, this.connection);
-		programMap.set(this.env, program);
+		program = getSwitchboardProgram(this.connection);
 		return program;
 	}
 }
 
-async function getSwitchboardProgram(
-	env: DriftEnv,
-	connection: Connection
-): Promise<Program> {
+function getSwitchboardProgram(connection: Connection): Program {
 	const DEFAULT_KEYPAIR = Keypair.fromSeed(new Uint8Array(32).fill(1));
-	const programId = getSwitchboardPid(env);
+	const programId = PublicKey.default;
 	const wallet = new Wallet(DEFAULT_KEYPAIR);
 	const provider = new AnchorProvider(connection, wallet, {});
 

package/src/oracles/types.ts

@@ -1,5 +1,6 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
 
 export type OraclePriceData = {
 	price: BN;
@@ -10,7 +11,12 @@ export type OraclePriceData = {
 	twapConfidence?: BN;
 };
 
+export type OracleInfo = {
+	publicKey: PublicKey;
+	source: OracleSource;
+};
+
 export interface OracleClient {
-	getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
+	getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
 	getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
 }