@drift-labs/sdk 0.1.22 → 0.1.23-master.3

package/src/math/orders.ts

@@ -42,3 +42,36 @@ export function isOrderRiskIncreasing(
 
 	return false;
 }
+
+export function isOrderRiskIncreasingInSameDirection(
+	user: ClearingHouseUser,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getUserPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if no position exists, it's risk increasing
+	if (position.baseAssetAmount.eq(ZERO)) {
+		return true;
+	}
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return true;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return true;
+	}
+
+	return false;
+}

package/src/math/position.ts

@@ -47,7 +47,8 @@ export function calculateBaseAssetValue(
 			return newQuoteAssetReserve
 				.sub(market.amm.quoteAssetReserve)
 				.mul(market.amm.pegMultiplier)
-				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+				.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+				.add(ONE);
 	}
 }
 
@@ -74,7 +75,7 @@ export function calculatePositionPNL(
 	if (marketPosition.baseAssetAmount.gt(ZERO)) {
 		pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
 	} else {
-		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue).sub(ONE);
+		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
 	}
 
 	if (withFunding) {

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { Market, PositionDirection } from '../types';
+import { isVariant, Market, 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,
+	ONE,
 } from '../constants/numericConstants';
 import { calculateMarkPrice } from './market';
 import {
@@ -114,16 +115,20 @@ export function calculateTradeAcquiredAmounts(
 		return [ZERO, ZERO];
 	}
 
+	const swapDirection = getSwapDirection(inputAssetType, direction);
 	const [newQuoteAssetReserve, newBaseAssetReserve] =
 		calculateAmmReservesAfterSwap(
 			market.amm,
 			inputAssetType,
 			amount,
-			getSwapDirection(inputAssetType, direction)
+			swapDirection
 		);
 
 	const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
-	const acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+	let acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+	if (inputAssetType === 'base' && isVariant(swapDirection, 'remove')) {
+		acquiredQuote = acquiredQuote.sub(ONE);
+	}
 
 	return [acquiredBase, acquiredQuote];
 }

package/src/orders.ts

@@ -3,16 +3,25 @@ import {
 	Market,
 	Order,
 	PositionDirection,
+	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import { BN } from '.';
+import {
+	BN,
+	calculateAmmReservesAfterSwap,
+	calculateBaseAssetValue,
+	ClearingHouseUser,
+	isOrderRiskIncreasingInSameDirection,
+	TEN_THOUSAND,
+} from '.';
 import {
 	calculateMarkPrice,
 	calculateNewMarketAfterTrade,
 } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
+	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -32,7 +41,10 @@ export function calculateNewStateAfterOrder(
 		return null;
 	}
 
-	const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
+		market,
+		order
+	);
 	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
 		return null;
 	}
@@ -157,7 +169,10 @@ function calculateAmountSwapped(
 	};
 }
 
-function calculateAmountToTrade(market: Market, order: Order): BN {
+export function calculateBaseAssetAmountMarketCanExecute(
+	market: Market,
+	order: Order
+): BN {
 	if (isVariant(order.orderType, 'limit')) {
 		return calculateAmountToTradeForLimit(market, order);
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
@@ -234,3 +249,41 @@ function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
 		return markPrice.lt(order.triggerPrice);
 	}
 }
+
+export function calculateBaseAssetAmountUserCanExecute(
+	market: Market,
+	order: Order,
+	user: ClearingHouseUser
+): BN {
+	const maxLeverage = user.getMaxLeverage('Initial');
+	const freeCollateral = user.getFreeCollateral();
+	let quoteAssetAmount: BN;
+	if (isOrderRiskIncreasingInSameDirection(user, order)) {
+		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
+	} else {
+		const position =
+			user.getUserPosition(order.marketIndex) ||
+			user.getEmptyPosition(order.marketIndex);
+		const positionValue = calculateBaseAssetValue(market, position);
+		quoteAssetAmount = freeCollateral
+			.mul(maxLeverage)
+			.div(TEN_THOUSAND)
+			.add(positionValue.mul(TWO));
+	}
+
+	if (quoteAssetAmount.lte(ZERO)) {
+		return ZERO;
+	}
+
+	const baseAssetReservesBefore = market.amm.baseAssetReserve;
+	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
+		market.amm,
+		'quote',
+		quoteAssetAmount,
+		isVariant(order.direction, 'long')
+			? SwapDirection.ADD
+			: SwapDirection.REMOVE
+	);
+
+	return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}

package/src/tx/retryTxSender.ts

@@ -0,0 +1,196 @@
+import { TxSender } from './types';
+import {
+	Commitment,
+	ConfirmOptions,
+	Context,
+	RpcResponseAndContext,
+	Signer,
+	SignatureResult,
+	Transaction,
+	TransactionSignature,
+} from '@solana/web3.js';
+import { Provider } from '@project-serum/anchor';
+import assert from 'assert';
+import bs58 from 'bs58';
+
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_RETRY = 8000;
+
+type ResolveReference = {
+	resolve?: () => void;
+};
+
+export class RetryTxSender implements TxSender {
+	provider: Provider;
+	timeout: number;
+	retrySleep: number;
+
+	public constructor(
+		provider: Provider,
+		timeout?: number,
+		retrySleep?: number
+	) {
+		this.provider = provider;
+		this.timeout = timeout ?? DEFAULT_TIMEOUT;
+		this.retrySleep = retrySleep ?? DEFAULT_RETRY;
+	}
+
+	async send(
+		tx: Transaction,
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions
+	): Promise<TransactionSignature> {
+		if (additionalSigners === undefined) {
+			additionalSigners = [];
+		}
+		if (opts === undefined) {
+			opts = this.provider.opts;
+		}
+
+		await this.prepareTx(tx, additionalSigners, opts);
+
+		const rawTransaction = tx.serialize();
+		const startTime = this.getTimestamp();
+
+		const txid: TransactionSignature =
+			await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+
+		let done = false;
+		const resolveReference: ResolveReference = {
+			resolve: undefined,
+		};
+		const stopWaiting = () => {
+			done = true;
+			if (resolveReference.resolve) {
+				resolveReference.resolve();
+			}
+		};
+
+		(async () => {
+			while (!done && this.getTimestamp() - startTime < this.timeout) {
+				await this.sleep(resolveReference);
+				if (!done) {
+					this.provider.connection
+						.sendRawTransaction(rawTransaction, opts)
+						.catch((e) => {
+							console.error(e);
+							stopWaiting();
+						});
+				}
+			}
+		})();
+
+		try {
+			await this.confirmTransaction(txid, opts.commitment);
+		} catch (e) {
+			console.error(e);
+			throw e;
+		} finally {
+			stopWaiting();
+		}
+
+		return txid;
+	}
+
+	async prepareTx(
+		tx: Transaction,
+		additionalSigners: Array<Signer>,
+		opts: ConfirmOptions
+	): Promise<Transaction> {
+		tx.feePayer = this.provider.wallet.publicKey;
+		tx.recentBlockhash = (
+			await this.provider.connection.getRecentBlockhash(
+				opts.preflightCommitment
+			)
+		).blockhash;
+
+		await this.provider.wallet.signTransaction(tx);
+		additionalSigners
+			.filter((s): s is Signer => s !== undefined)
+			.forEach((kp) => {
+				tx.partialSign(kp);
+			});
+
+		return tx;
+	}
+
+	async confirmTransaction(
+		signature: TransactionSignature,
+		commitment?: Commitment
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		let decodedSignature;
+		try {
+			decodedSignature = bs58.decode(signature);
+		} catch (err) {
+			throw new Error('signature must be base58 encoded: ' + signature);
+		}
+
+		assert(decodedSignature.length === 64, 'signature has invalid length');
+
+		const start = Date.now();
+		const subscriptionCommitment = commitment || this.provider.opts.commitment;
+
+		let subscriptionId;
+		let response: RpcResponseAndContext<SignatureResult> | null = null;
+		const confirmPromise = new Promise((resolve, reject) => {
+			try {
+				subscriptionId = this.provider.connection.onSignature(
+					signature,
+					(result: SignatureResult, context: Context) => {
+						subscriptionId = undefined;
+						response = {
+							context,
+							value: result,
+						};
+						resolve(null);
+					},
+					subscriptionCommitment
+				);
+			} catch (err) {
+				reject(err);
+			}
+		});
+
+		try {
+			await this.promiseTimeout(confirmPromise, this.timeout);
+		} finally {
+			if (subscriptionId) {
+				this.provider.connection.removeSignatureListener(subscriptionId);
+			}
+		}
+
+		if (response === null) {
+			const duration = (Date.now() - start) / 1000;
+			throw new Error(
+				`Transaction was not confirmed in ${duration.toFixed(
+					2
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`
+			);
+		}
+
+		return response;
+	}
+
+	getTimestamp(): number {
+		return new Date().getTime();
+	}
+
+	async sleep(reference: ResolveReference): Promise<void> {
+		return new Promise((resolve) => {
+			reference.resolve = resolve;
+			setTimeout(resolve, this.retrySleep);
+		});
+	}
+
+	promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null> {
+		let timeoutId: ReturnType<typeof setTimeout>;
+		const timeoutPromise: Promise<null> = new Promise((resolve) => {
+			timeoutId = setTimeout(() => resolve(null), timeoutMs);
+		});
+
+		return Promise.race([promise, timeoutPromise]).then((result: T | null) => {
+			clearTimeout(timeoutId);
+			return result;
+		});
+	}
+}

package/src/tx/types.ts

@@ -1,3 +1,4 @@
+import { Provider } from '@project-serum/anchor';
 import {
 	ConfirmOptions,
 	Signer,
@@ -6,6 +7,8 @@ import {
 } from '@solana/web3.js';
 
 export interface TxSender {
+	provider: Provider;
+
 	send(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,