@drift-labs/sdk 0.1.18-orders.1 → 0.1.18

package/lib/orderParams.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMarketOrderParams = exports.getStopLimitOrderParams = exports.getStopOrderParams = exports.getLimitOrderParams = void 0;
-const types_1 = require("./types");
-const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false) {
-    return {
-        orderType: types_1.OrderType.LIMIT,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-    };
-}
-exports.getLimitOrderParams = getLimitOrderParams;
-function getStopOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false) {
-    return {
-        orderType: types_1.OrderType.STOP,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price: numericConstants_1.ZERO,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-    };
-}
-exports.getStopOrderParams = getStopOrderParams;
-function getStopLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false) {
-    return {
-        orderType: types_1.OrderType.STOP_LIMIT,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-    };
-}
-exports.getStopLimitOrderParams = getStopLimitOrderParams;
-function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAssetAmount, reduceOnly, price = numericConstants_1.ZERO, discountToken = false, referrer = false) {
-    if (baseAssetAmount.eq(numericConstants_1.ZERO) && quoteAssetAmount.eq(numericConstants_1.ZERO)) {
-        throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-    }
-    return {
-        orderType: types_1.OrderType.MARKET,
-        marketIndex,
-        direction,
-        quoteAssetAmount,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-    };
-}
-exports.getMarketOrderParams = getMarketOrderParams;

package/lib/orders.d.ts

@@ -1,5 +0,0 @@
-import { Market, Order, UserAccount, UserPosition } from './types';
-import BN from 'bn.js';
-export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
-export declare function calculateAmountToTradeForLimit(market: Market, order: Order): BN;
-export declare function calculateAmountToTradeForStopLimit(market: Market, order: Order): BN;

package/lib/orders.js

@@ -1,136 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForStopLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
-const types_1 = require("./types");
-const market_1 = require("./math/market");
-const numericConstants_1 = require("./constants/numericConstants");
-const amm_1 = require("./math/amm");
-const position_1 = require("./math/position");
-function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if (types_1.isVariant(order.status, 'init')) {
-        return null;
-    }
-    const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
-        return null;
-    }
-    const userAccountAfter = Object.assign({}, userAccount);
-    const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
-    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
-        isSameDirection(order.direction, currentPositionDirection);
-    if (increasePosition) {
-        const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
-        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
-        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
-        return [userAccountAfter, userPositionAfter, marketAfter];
-    }
-    else {
-        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
-        if (reversePosition) {
-            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
-            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
-            let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-            }
-            else {
-                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
-            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
-            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-        else {
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
-            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
-            const costBasisRealized = userPosition.quoteAssetAmount
-                .mul(baseAssetAmountSwapped.abs())
-                .div(userPosition.baseAssetAmount.abs());
-            let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(costBasisRealized);
-            }
-            else {
-                pnl = costBasisRealized.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-            userPositionAfter.quoteAssetAmount =
-                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-    }
-}
-exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
-function calculateAmountSwapped(marketBefore, marketAfter) {
-    return {
-        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-            .sub(marketAfter.amm.quoteAssetReserve)
-            .abs()
-            .mul(marketBefore.amm.pegMultiplier)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
-        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
-    };
-}
-function calculateAmountToTrade(market, order) {
-    if (types_1.isVariant(order.orderType, 'limit')) {
-        return calculateAmountToTradeForLimit(market, order);
-    }
-    else if (types_1.isVariant(order.orderType, 'stopLimit')) {
-        return calculateAmountToTradeForStopLimit(market, order);
-    }
-    else if (types_1.isVariant(order.orderType, 'market')) {
-        // should never be a market order queued
-        return numericConstants_1.ZERO;
-    }
-    else {
-        return calculateAmountToTradeForStop(market, order);
-    }
-}
-function calculateAmountToTradeForLimit(market, order) {
-    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, order.price);
-    // Check that directions are the same
-    const sameDirection = isSameDirection(direction, order.direction);
-    if (!sameDirection) {
-        return numericConstants_1.ZERO;
-    }
-    return maxAmountToTrade.gt(order.baseAssetAmount)
-        ? order.baseAssetAmount
-        : maxAmountToTrade;
-}
-exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
-function calculateAmountToTradeForStopLimit(market, order) {
-    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForStop(market, order);
-        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.ZERO;
-        }
-    }
-    return calculateAmountToTradeForLimit(market, order);
-}
-exports.calculateAmountToTradeForStopLimit = calculateAmountToTradeForStopLimit;
-function isSameDirection(firstDirection, secondDirection) {
-    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
-        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
-}
-function calculateAmountToTradeForStop(market, order) {
-    return isTriggerConditionSatisfied(market, order)
-        ? order.baseAssetAmount
-        : numericConstants_1.ZERO;
-}
-function isTriggerConditionSatisfied(market, order) {
-    const markPrice = market_1.calculateMarkPrice(market);
-    if (types_1.isVariant(order.triggerCondition, 'above')) {
-        return markPrice.gt(order.triggerPrice);
-    }
-    else {
-        return markPrice.lt(order.triggerPrice);
-    }
-}

package/src/accounts/defaultHistoryAccountSubscriber.ts

@@ -1,176 +0,0 @@
-import { ClearingHouseAccountEvents, HistoryAccountSubscriber } from './types';
-import { AccountSubscriber, NotSubscribedError } from './types';
-import {
-	CurveHistoryAccount,
-	DepositHistoryAccount,
-	FundingPaymentHistoryAccount,
-	FundingRateHistoryAccount,
-	LiquidationHistoryAccount,
-	TradeHistoryAccount,
-} from '../types';
-import { Program } from '@project-serum/anchor';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-import { getClearingHouseStateAccountPublicKey } from '../addresses';
-import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-
-export class DefaultHistoryAccountSubscriber
-	implements HistoryAccountSubscriber
-{
-	isSubscribed: boolean;
-	program: Program;
-	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
-	tradeHistoryAccountSubscriber?: AccountSubscriber<TradeHistoryAccount>;
-	depositHistoryAccountSubscriber?: AccountSubscriber<DepositHistoryAccount>;
-	fundingPaymentHistoryAccountSubscriber?: AccountSubscriber<FundingPaymentHistoryAccount>;
-	fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
-	curveHistoryAccountSubscriber?: AccountSubscriber<CurveHistoryAccount>;
-	liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
-
-	public constructor(program: Program) {
-		this.isSubscribed = false;
-		this.program = program;
-		this.eventEmitter = new EventEmitter();
-	}
-
-	public async subscribe(): Promise<boolean> {
-		if (this.isSubscribed) {
-			return true;
-		}
-
-		const statePublicKey = await getClearingHouseStateAccountPublicKey(
-			this.program.programId
-		);
-		const state: any = await this.program.account.state.fetch(statePublicKey);
-
-		this.tradeHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'tradeHistory',
-			this.program,
-			state.tradeHistory
-		);
-		await this.tradeHistoryAccountSubscriber.subscribe(
-			(data: TradeHistoryAccount) => {
-				this.eventEmitter.emit('tradeHistoryAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.depositHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'depositHistory',
-			this.program,
-			state.depositHistory
-		);
-		await this.depositHistoryAccountSubscriber.subscribe(
-			(data: DepositHistoryAccount) => {
-				this.eventEmitter.emit('depositHistoryAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.fundingPaymentHistoryAccountSubscriber =
-			new WebSocketAccountSubscriber(
-				'fundingPaymentHistory',
-				this.program,
-				state.fundingPaymentHistory
-			);
-		await this.fundingPaymentHistoryAccountSubscriber.subscribe(
-			(data: FundingPaymentHistoryAccount) => {
-				this.eventEmitter.emit('fundingPaymentHistoryAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.fundingRateHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'fundingRateHistory',
-			this.program,
-			state.fundingRateHistory
-		);
-		await this.fundingRateHistoryAccountSubscriber.subscribe(
-			(data: FundingRateHistoryAccount) => {
-				this.eventEmitter.emit('fundingRateHistoryAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.liquidationHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'liquidationHistory',
-			this.program,
-			state.liquidationHistory
-		);
-		await this.liquidationHistoryAccountSubscriber.subscribe(
-			(data: LiquidationHistoryAccount) => {
-				this.eventEmitter.emit('liquidationHistoryAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.curveHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'curveHistory',
-			this.program,
-			state.curveHistory
-		);
-		await this.curveHistoryAccountSubscriber.subscribe(
-			(data: CurveHistoryAccount) => {
-				this.eventEmitter.emit('curveHistoryAccountUpdate', data);
-				this.eventEmitter.emit('update');
-			}
-		);
-
-		this.eventEmitter.emit('update');
-
-		this.isSubscribed = true;
-		return true;
-	}
-
-	public async unsubscribe(): Promise<void> {
-		if (!this.isSubscribed) {
-			return;
-		}
-
-		await this.tradeHistoryAccountSubscriber.unsubscribe();
-		await this.fundingRateHistoryAccountSubscriber.unsubscribe();
-		await this.fundingPaymentHistoryAccountSubscriber.unsubscribe();
-		await this.depositHistoryAccountSubscriber.unsubscribe();
-		await this.curveHistoryAccountSubscriber.unsubscribe();
-		await this.liquidationHistoryAccountSubscriber.unsubscribe();
-		this.isSubscribed = false;
-	}
-
-	assertIsSubscribed(): void {
-		if (!this.isSubscribed) {
-			throw new NotSubscribedError(
-				'You must call `subscribe` before using this function'
-			);
-		}
-	}
-
-	public getTradeHistoryAccount(): TradeHistoryAccount {
-		this.assertIsSubscribed();
-		return this.tradeHistoryAccountSubscriber.data;
-	}
-
-	public getDepositHistoryAccount(): DepositHistoryAccount {
-		this.assertIsSubscribed();
-		return this.depositHistoryAccountSubscriber.data;
-	}
-
-	public getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount {
-		this.assertIsSubscribed();
-		return this.fundingPaymentHistoryAccountSubscriber.data;
-	}
-
-	public getFundingRateHistoryAccount(): FundingRateHistoryAccount {
-		this.assertIsSubscribed();
-		return this.fundingRateHistoryAccountSubscriber.data;
-	}
-
-	public getCurveHistoryAccount(): CurveHistoryAccount {
-		this.assertIsSubscribed();
-		return this.curveHistoryAccountSubscriber.data;
-	}
-
-	public getLiquidationHistoryAccount(): LiquidationHistoryAccount {
-		this.assertIsSubscribed();
-		return this.liquidationHistoryAccountSubscriber.data;
-	}
-}

package/src/math/orders.ts

@@ -1,39 +0,0 @@
-import { ClearingHouseUser } from '../clearingHouseUser';
-import { isVariant, Order } from '../types';
-import { ZERO } from '../constants/numericConstants';
-
-export function isOrderRiskIncreasing(
-	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;
-	}
-
-	// if order will flip position
-	if (position.baseAssetAmount.abs().gt(order.baseAssetAmountFilled)) {
-		return true;
-	}
-}

package/src/orderParams.ts

@@ -1,128 +0,0 @@
-import {
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-	PositionDirection,
-} from './types';
-import { BN } from '@project-serum/anchor';
-import { ZERO } from './constants/numericConstants';
-
-export function getLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	return {
-		orderType: OrderType.LIMIT,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-	};
-}
-
-export function getStopOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	return {
-		orderType: OrderType.STOP,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price: ZERO,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-	};
-}
-
-export function getStopLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	return {
-		orderType: OrderType.STOP_LIMIT,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-	};
-}
-
-export function getMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	quoteAssetAmount: BN,
-	baseAssetAmount: BN,
-	reduceOnly: boolean,
-	price = ZERO,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	if (baseAssetAmount.eq(ZERO) && quoteAssetAmount.eq(ZERO)) {
-		throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-	}
-
-	return {
-		orderType: OrderType.MARKET,
-		marketIndex,
-		direction,
-		quoteAssetAmount,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-	};
-}