@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.12

package/lib/math/orders.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="bn.js" />
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { Order } from '../types';
+import { MarketAccount, Order } from '../types';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
 export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderReduceOnly(user: ClearingHouseUser, order: Order): boolean;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
-export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function getLimitPrice(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;

package/lib/math/orders.js

@@ -5,6 +5,7 @@ const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
 const auction_1 = require("./auction");
+const market_1 = require("./market");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
         return false;
@@ -78,23 +79,29 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
     return baseAssetAmount.sub(remainder);
 }
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, oraclePriceData, slot) {
+function getLimitPrice(order, market, oraclePriceData, slot) {
     let limitPrice;
     if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-        if (order.postOnly) {
-            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
-                ? anchor_1.BN.min(order.price, floatingPrice)
-                : anchor_1.BN.max(order.price, floatingPrice);
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
+        if ((0, auction_1.isAuctionComplete)(order, slot)) {
+            limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
+        }
+        else if (!order.price.eq(numericConstants_1.ZERO)) {
+            limitPrice = order.price;
+        }
+        else if ((0, types_1.isVariant)(order.direction, 'long')) {
+            const askPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+            const delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = askPrice.add(delta);
         }
         else {
-            limitPrice = floatingPrice;
+            const bidPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+            const delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
+            limitPrice = bidPrice.sub(delta);
         }
     }
-    else if ((0, types_1.isVariant)(order.orderType, 'market') ||
-        (0, types_1.isVariant)(order.orderType, 'triggerMarket')) {
-        limitPrice = (0, auction_1.getAuctionPrice)(order, slot);
-    }
     else {
         limitPrice = order.price;
     }

package/lib/math/position.d.ts

@@ -17,9 +17,11 @@ export declare function calculateBaseAssetValue(market: MarketAccount, userPosit
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculateUnsettledPnl(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
 /**
  *
  * @param market
@@ -34,6 +36,12 @@ export declare function positionIsAvailable(position: UserPosition): boolean;
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
 export declare function calculateEntryPrice(userPosition: UserPosition): BN;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+export declare function calculateCostBasis(userPosition: UserPosition): BN;
 export declare function findDirectionToClose(userPosition: UserPosition): PositionDirection;
 export declare function positionCurrentDirection(userPosition: UserPosition): PositionDirection;
 export declare function isEmptyPosition(userPosition: UserPosition): boolean;

package/lib/math/position.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledPnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const margin_1 = require("./margin");
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -53,20 +54,20 @@ exports.calculateBaseAssetValue = calculateBaseAssetValue;
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
     if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
-    let pnl;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-    }
-    else {
-        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
+        return marketPosition.quoteAssetAmount;
     }
+    const baseAssetValue = (0, margin_1.calculateMarginBaseAssetValue)(market, marketPosition, oraclePriceData);
+    const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    let pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(marketPosition.quoteAssetAmount);
     if (withFunding) {
         const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
         pnl = pnl.add(fundingRatePnL);
@@ -74,6 +75,19 @@ function calculatePositionPNL(market, marketPosition, withFunding = false, oracl
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
+function calculateUnsettledPnl(market, marketPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, marketPosition, true, oraclePriceData);
+    let unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const maxPositivePnl = __1.BN.max(marketPosition.quoteAssetAmount
+            .add(marketPosition.quoteEntryAmount)
+            .add(fundingPnL), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateUnsettledPnl = calculateUnsettledPnl;
 /**
  *
  * @param market
@@ -101,7 +115,9 @@ function calculatePositionFundingPNL(market, marketPosition) {
 }
 exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
 function positionIsAvailable(position) {
-    return position.baseAssetAmount.eq(numericConstants_1.ZERO) && position.openOrders.eq(numericConstants_1.ZERO);
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders.eq(numericConstants_1.ZERO) &&
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO));
 }
 exports.positionIsAvailable = positionIsAvailable;
 /**
@@ -113,13 +129,29 @@ function calculateEntryPrice(userPosition) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    return userPosition.quoteAssetAmount
+    return userPosition.quoteEntryAmount
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)
         .abs();
 }
 exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateCostBasis = calculateCostBasis;
 function findDirectionToClose(userPosition) {
     return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT

package/lib/math/repeg.js

@@ -107,7 +107,7 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     const targetPeg = targetPrice
         .mul(amm.baseAssetReserve)
         .div(amm.quoteAssetReserve)
-        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION));
+        .div(numericConstants_1.PRICE_DIV_PEG);
     const k = amm.sqrtK.mul(amm.sqrtK);
     const x = amm.baseAssetReserve;
     const y = amm.quoteAssetReserve;

package/lib/math/trade.d.ts

@@ -33,7 +33,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades

package/lib/math/trade.js

@@ -43,15 +43,11 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
-    const swapDirection = (0, types_2.isVariant)(direction, 'long')
-        ? types_1.SwapDirection.REMOVE
-        : types_1.SwapDirection.ADD;
-    const quoteAssetAmountAcquired = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), market.amm.pegMultiplier, swapDirection);
-    const entryPrice = quoteAssetAmountAcquired
+    const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
+    const entryPrice = acquiredQuoteAssetAmount
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(acquiredBase.abs());
+        .div(acquiredBaseReserve.abs());
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
         const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData);
@@ -65,7 +61,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
     else {
         amm = market.amm;
     }
-    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBase), amm.quoteAssetReserve.sub(acquiredQuote), amm.pegMultiplier);
+    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
         (0, assert_1.assert)(newPrice.lte(oldPrice));
     }
@@ -98,7 +94,7 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  */
 function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
     if (amount.eq(numericConstants_1.ZERO)) {
-        return [numericConstants_1.ZERO, numericConstants_1.ZERO];
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
     const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
     let amm;
@@ -117,7 +113,8 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
     const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    return [acquiredBase, acquiredQuote];
+    const acquiredQuoteAssetamount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**

package/lib/orderParams.d.ts

@@ -1,7 +1,16 @@
 /// <reference types="bn.js" />
-import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
+import { OptionalOrderParams, OrderTriggerCondition } from './types';
 import { BN } from '@project-serum/anchor';
-export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number, postOnly?: boolean, oraclePriceOffset?: BN, immediateOrCancel?: boolean): OrderParams;
-export declare function getTriggerMarketOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
-export declare function getTriggerLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
-export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    price: BN;
+}): OptionalOrderParams;
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+}): OptionalOrderParams;
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+    triggerCondition: OrderTriggerCondition;
+    triggerPrice: BN;
+    price: BN;
+}): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'>): OptionalOrderParams;

package/lib/orderParams.js

@@ -2,107 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = 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, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO, immediateOrCancel = false) {
-    return {
-        orderType: types_1.OrderType.LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly,
-        immediateOrCancel,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset,
-    };
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
 }
 exports.getLimitOrderParams = getLimitOrderParams;
-function getTriggerMarketOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
-        orderType: types_1.OrderType.TRIGGER_MARKET,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price: numericConstants_1.ZERO,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
 }
 exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
-function getTriggerLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
-    return {
-        orderType: types_1.OrderType.TRIGGER_LIMIT,
-        userOrderId,
-        marketIndex,
-        direction,
-        quoteAssetAmount: numericConstants_1.ZERO,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition,
-        triggerPrice,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
 }
 exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
-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,
-        userOrderId: 0,
-        marketIndex,
-        direction,
-        quoteAssetAmount,
-        baseAssetAmount,
-        price,
-        reduceOnly,
-        postOnly: false,
-        immediateOrCancel: false,
-        positionLimit: numericConstants_1.ZERO,
-        padding0: true,
-        padding1: numericConstants_1.ZERO,
-        optionalAccounts: {
-            discountToken,
-            referrer,
-        },
-        triggerCondition: types_1.OrderTriggerCondition.ABOVE,
-        triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset: numericConstants_1.ZERO,
-    };
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/orders.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="bn.js" />
-import { MarketAccount, Order, UserAccount, UserPosition } from './types';
-import { BN, ClearingHouseUser } from '.';
+import { MarketAccount, Order } from './types';
+import { BN } from '.';
 import { OraclePriceData } from '.';
-export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: MarketAccount, order: Order): [UserAccount, UserPosition, MarketAccount] | null;
 export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;
-export declare function calculateBaseAssetAmountUserCanExecute(market: MarketAccount, order: Order, user: ClearingHouseUser, oraclePriceData?: OraclePriceData): BN;

package/lib/orders.js

@@ -1,85 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = void 0;
 const types_1 = require("./types");
 const _1 = require(".");
-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 ((0, types_1.isVariant)(order.status, 'init')) {
-        return null;
-    }
-    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-        return null;
-    }
-    const userAccountAfter = Object.assign({}, userAccount);
-    const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = (0, position_1.positionCurrentDirection)(userPosition);
-    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
-        isSameDirection(order.direction, currentPositionDirection);
-    if (increasePosition) {
-        const marketAfter = (0, 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 = (0, market_1.calculateNewMarketAfterTrade)(userPosition.baseAssetAmount, (0, position_1.findDirectionToClose)(userPosition), market);
-            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
-            let pnl;
-            if ((0, 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 = (0, 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 = (0, 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 ((0, 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 calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
     if ((0, types_1.isVariant)(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order, oraclePriceData);
@@ -88,7 +13,6 @@ function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
     else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        // should never be a market order queued
         return numericConstants_1.ZERO;
     }
     else {
@@ -102,17 +26,9 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
         if (!oraclePriceData) {
             throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
         }
-        const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-        if (order.postOnly) {
-            limitPrice = (0, types_1.isVariant)(order.direction, 'long')
-                ? _1.BN.min(order.price, floatingPrice)
-                : _1.BN.max(order.price, floatingPrice);
-        }
-        else {
-            limitPrice = floatingPrice;
-        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
     }
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
     const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
@@ -125,11 +41,8 @@ function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
 }
 exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
 function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
-        if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
-            return numericConstants_1.ZERO;
-        }
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
     }
     return calculateAmountToTradeForLimit(market, order);
 }
@@ -139,75 +52,8 @@ function isSameDirection(firstDirection, secondDirection) {
         ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
 }
 function calculateAmountToTradeForTriggerMarket(market, order) {
-    return isTriggerConditionSatisfied(market, order)
-        ? order.baseAssetAmount
-        : numericConstants_1.ZERO;
-}
-function isTriggerConditionSatisfied(market, order, oraclePriceData) {
-    const markPrice = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
-    if ((0, types_1.isVariant)(order.triggerCondition, 'above')) {
-        return markPrice.gt(order.triggerPrice);
-    }
-    else {
-        return markPrice.lt(order.triggerPrice);
-    }
-}
-function calculateBaseAssetAmountUserCanExecute(market, order, user, oraclePriceData) {
-    const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-    const freeCollateral = user.getFreeCollateral();
-    let quoteAssetAmount;
-    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
-        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
-    }
-    else {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        const positionValue = (0, _1.calculateBaseAssetValue)(market, position, oraclePriceData);
-        quoteAssetAmount = freeCollateral
-            .mul(maxLeverage)
-            .div(_1.TEN_THOUSAND)
-            .add(positionValue.mul(numericConstants_1.TWO));
-    }
-    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+    if (!order.triggered) {
         return numericConstants_1.ZERO;
     }
-    const swapDirection = (0, types_1.isVariant)(order.direction, 'long')
-        ? types_1.SwapDirection.ADD
-        : types_1.SwapDirection.REMOVE;
-    const useSpread = !order.postOnly;
-    let amm;
-    if (useSpread) {
-        const { baseAssetReserve, quoteAssetReserve } = (0, _1.calculateSpreadReserves)(market.amm, order.direction, oraclePriceData);
-        amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: market.amm.sqrtK,
-            pegMultiplier: market.amm.pegMultiplier,
-        };
-    }
-    else {
-        amm = market.amm;
-    }
-    const baseAssetReservesBefore = amm.baseAssetReserve;
-    const [_, baseAssetReservesAfter] = (0, _1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteAssetAmount, swapDirection);
-    let baseAssetAmount = baseAssetReservesBefore
-        .sub(baseAssetReservesAfter)
-        .abs();
-    if (order.reduceOnly) {
-        const position = user.getUserPosition(order.marketIndex) ||
-            user.getEmptyPosition(order.marketIndex);
-        if ((0, types_1.isVariant)(order.direction, 'long') &&
-            position.baseAssetAmount.gte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else if ((0, types_1.isVariant)(order.direction, 'short') &&
-            position.baseAssetAmount.lte(numericConstants_1.ZERO)) {
-            baseAssetAmount = numericConstants_1.ZERO;
-        }
-        else {
-            _1.BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-        }
-    }
-    return baseAssetAmount;
+    return order.baseAssetAmount;
 }
-exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/slot/SlotSubscriber.d.ts

@@ -1,9 +1,16 @@
+/// <reference types="node" />
 import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 declare type SlotSubscriberConfig = {};
+export interface SlotSubscriberEvents {
+    newSlot: (newSlot: number) => void;
+}
 export declare class SlotSubscriber {
     private connection;
     currentSlot: number;
     subscriptionId: number;
+    eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
     constructor(connection: Connection, _config?: SlotSubscriberConfig);
     subscribe(): Promise<void>;
     getSlot(): number;

package/lib/slot/SlotSubscriber.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlotSubscriber = void 0;
+const events_1 = require("events");
 class SlotSubscriber {
     constructor(connection, _config) {
         this.connection = connection;
+        this.eventEmitter = new events_1.EventEmitter();
     }
     async subscribe() {
         this.currentSlot = await this.connection.getSlot('confirmed');
         this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
             this.currentSlot = slotInfo.slot;
+            this.eventEmitter.emit('newSlot', slotInfo.slot);
         });
     }
     getSlot() {