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

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export * from './mockUSDCFaucet';
 export * from './pythClient';
 export * from './types';
 export * from './constants/markets';
+export * from './accounts/defaultHistoryAccountSubscriber';
 export * from './accounts/defaultClearingHouseAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses';
@@ -16,6 +17,9 @@ export * from './math/market';
 export * from './math/position';
 export * from './math/amm';
 export * from './math/trade';
+export * from './math/orders';
+export * from './orders';
+export * from './orderParams';
 export * from './wallet';
 export * from './types';
 export * from './math/utils';
@@ -24,4 +28,3 @@ export * from './constants/numericConstants';
 export * from './util/computeUnits';
 export * from './util/tps';
 export { BN };
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -17,6 +17,7 @@ __exportStar(require("./mockUSDCFaucet"), exports);
 __exportStar(require("./pythClient"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants/markets"), exports);
+__exportStar(require("./accounts/defaultHistoryAccountSubscriber"), exports);
 __exportStar(require("./accounts/defaultClearingHouseAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
 __exportStar(require("./addresses"), exports);
@@ -30,6 +31,9 @@ __exportStar(require("./math/market"), exports);
 __exportStar(require("./math/position"), exports);
 __exportStar(require("./math/amm"), exports);
 __exportStar(require("./math/trade"), exports);
+__exportStar(require("./math/orders"), exports);
+__exportStar(require("./orders"), exports);
+__exportStar(require("./orderParams"), exports);
 __exportStar(require("./wallet"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./math/utils"), exports);

package/lib/math/amm.d.ts

@@ -63,4 +63,4 @@ export declare function calculateRepegCost(market: Market, marketIndex: BN, newP
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
 export declare function calculateTerminalPrice(market: Market): BN;
-//# sourceMappingURL=amm.d.ts.map
+export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN): [BN, PositionDirection];

package/lib/math/amm.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
+exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const position_1 = require("./position");
@@ -36,7 +36,7 @@ exports.calculatePrice = calculatePrice;
  * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
  */
 function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDirection) {
-    (0, assert_1.assert)(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
+    assert_1.assert(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
     let newQuoteAssetReserve;
     let newBaseAssetReserve;
     if (inputAssetType === 'quote') {
@@ -79,12 +79,10 @@ exports.calculateSwapOutput = calculateSwapOutput;
  * @param positionDirection
  */
 function getSwapDirection(inputAssetType, positionDirection) {
-    if (positionDirection === types_1.PositionDirection.LONG &&
-        inputAssetType === 'base') {
+    if (types_1.isVariant(positionDirection, 'long') && inputAssetType === 'base') {
         return types_1.SwapDirection.REMOVE;
     }
-    if (positionDirection === types_1.PositionDirection.SHORT &&
-        inputAssetType === 'quote') {
+    if (types_1.isVariant(positionDirection, 'short') && inputAssetType === 'quote') {
         return types_1.SwapDirection.REMOVE;
     }
     return types_1.SwapDirection.ADD;
@@ -104,8 +102,9 @@ function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
         lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
         marketIndex: new anchor_1.BN(marketIndex),
         quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: new anchor_1.BN(0),
     };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    const currentValue = position_1.calculateBaseAssetValue(market, netUserPosition);
     const marketNewK = Object.assign({}, market);
     marketNewK.amm = Object.assign({}, market.amm);
     marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
@@ -116,7 +115,7 @@ function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
         .div(denomenator);
     marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
     netUserPosition.quoteAssetAmount = currentValue;
-    const cost = (0, __1.calculatePositionPNL)(marketNewK, netUserPosition);
+    const cost = __1.calculatePositionPNL(marketNewK, netUserPosition);
     return cost;
 }
 exports.calculateAdjustKCost = calculateAdjustKCost;
@@ -134,16 +133,17 @@ function calculateRepegCost(market, marketIndex, newPeg) {
         lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
         marketIndex: new anchor_1.BN(marketIndex),
         quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: new anchor_1.BN(0),
     };
-    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    const currentValue = position_1.calculateBaseAssetValue(market, netUserPosition);
     netUserPosition.quoteAssetAmount = currentValue;
-    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
+    const prevMarketPrice = __1.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', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
-    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
+    console.log('Price moves from', __1.convertToNumber(prevMarketPrice), 'to', __1.convertToNumber(__1.calculateMarkPrice(marketNewPeg)));
+    const cost = __1.calculatePositionPNL(marketNewPeg, netUserPosition);
     return cost;
 }
 exports.calculateRepegCost = calculateRepegCost;
@@ -154,9 +154,6 @@ exports.calculateRepegCost = calculateRepegCost;
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
 function calculateTerminalPrice(market) {
-    if (!market.initialized) {
-        return new anchor_1.BN(0);
-    }
     const directionToClose = market.baseAssetAmount.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT
         : types_1.PositionDirection.LONG;
@@ -169,3 +166,29 @@ function calculateTerminalPrice(market) {
     return terminalPrice;
 }
 exports.calculateTerminalPrice = calculateTerminalPrice;
+function calculateMaxBaseAssetAmountToTrade(amm, limit_price) {
+    const invariant = amm.sqrtK.mul(amm.sqrtK);
+    const newBaseAssetReserveSquared = invariant
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(amm.pegMultiplier)
+        .div(limit_price)
+        .div(numericConstants_1.PEG_PRECISION);
+    const newBaseAssetReserve = __1.squareRootBN(newBaseAssetReserveSquared);
+    if (newBaseAssetReserve.gt(amm.baseAssetReserve)) {
+        return [
+            newBaseAssetReserve.sub(amm.baseAssetReserve),
+            types_1.PositionDirection.SHORT,
+        ];
+    }
+    else if (newBaseAssetReserve.lt(amm.baseAssetReserve)) {
+        return [
+            amm.baseAssetReserve.sub(newBaseAssetReserve),
+            types_1.PositionDirection.LONG,
+        ];
+    }
+    else {
+        console.log('tradeSize Too Small');
+        return [new anchor_1.BN(0), types_1.PositionDirection.LONG];
+    }
+}
+exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;

package/lib/math/conversion.d.ts

@@ -1,4 +1,3 @@
 import BN from 'bn.js';
 export declare const convertToNumber: (bigNumber: BN, precision?: BN) => number;
 export declare const convertBaseAssetAmountToNumber: (baseAssetAmount: BN) => number;
-//# sourceMappingURL=conversion.d.ts.map

package/lib/math/conversion.js

@@ -10,6 +10,6 @@ const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PR
 };
 exports.convertToNumber = convertToNumber;
 const convertBaseAssetAmountToNumber = (baseAssetAmount) => {
-    return (0, exports.convertToNumber)(baseAssetAmount, numericConstants_1.MARK_PRICE_PRECISION.mul(numericConstants_1.PEG_PRECISION));
+    return exports.convertToNumber(baseAssetAmount, numericConstants_1.MARK_PRICE_PRECISION.mul(numericConstants_1.PEG_PRECISION));
 };
 exports.convertBaseAssetAmountToNumber = convertBaseAssetAmountToNumber;

package/lib/math/funding.d.ts

@@ -41,4 +41,3 @@ export declare function calculateLongShortFundingRateAndLiveTwaps(market: Market
  * @returns Estimated fee pool size
  */
 export declare function calculateFundingPool(market: Market): BN;
-//# sourceMappingURL=funding.d.ts.map

package/lib/math/funding.js

@@ -40,7 +40,7 @@ function calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustm
         const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
         const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
         const markTwapTimeSinceLastUpdate = anchor_1.BN.max(secondsInHour, secondsInHour.sub(timeSinceLastMarkChange));
-        const baseAssetPriceWithMantissa = (0, market_1.calculateMarkPrice)(market);
+        const baseAssetPriceWithMantissa = market_1.calculateMarkPrice(market);
         const markTwapWithMantissa = markTwapTimeSinceLastUpdate
             .mul(lastMarkTwapWithMantissa)
             .add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))

package/lib/math/insuranceFund.d.ts

@@ -12,4 +12,3 @@ import { Connection } from '@solana/web3.js';
  * @returns Precision : QUOTE_ASSET_PRECISION
  */
 export declare function calculateInsuranceFundSize(connection: Connection, state: StateAccount, marketsAccount: MarketsAccount): Promise<BN>;
-//# sourceMappingURL=insuranceFund.d.ts.map

package/lib/math/market.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { Market } from '../types';
+import { Market, PositionDirection } from '../types';
 /**
  * Calculates market mark price
  *
@@ -8,4 +8,4 @@ import { Market } from '../types';
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
 export declare function calculateMarkPrice(market: Market): BN;
-//# sourceMappingURL=market.d.ts.map
+export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: Market): Market;

package/lib/math/market.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMarkPrice = void 0;
+exports.calculateNewMarketAfterTrade = exports.calculateMarkPrice = void 0;
 const amm_1 = require("./amm");
 /**
  * Calculates market mark price
@@ -9,6 +9,16 @@ const amm_1 = require("./amm");
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
 function calculateMarkPrice(market) {
-    return (0, amm_1.calculatePrice)(market.amm.baseAssetReserve, market.amm.quoteAssetReserve, market.amm.pegMultiplier);
+    return amm_1.calculatePrice(market.amm.baseAssetReserve, market.amm.quoteAssetReserve, market.amm.pegMultiplier);
 }
 exports.calculateMarkPrice = calculateMarkPrice;
+function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', baseAssetAmount.abs(), amm_1.getSwapDirection('base', direction));
+    const newAmm = Object.assign({}, market.amm);
+    const newMarket = Object.assign({}, market);
+    newMarket.amm = newAmm;
+    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+    return newMarket;
+}
+exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;

package/lib/math/orders.d.ts

@@ -0,0 +1,3 @@
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { Order } from '../types';
+export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Order): boolean;

package/lib/math/orders.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOrderRiskIncreasing = void 0;
+const types_1 = require("../types");
+const numericConstants_1 = require("../constants/numericConstants");
+function isOrderRiskIncreasing(user, order) {
+    if (types_1.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(numericConstants_1.ZERO)) {
+        return true;
+    }
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
+        return true;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return true;
+    }
+    // if order will flip position
+    if (position.baseAssetAmount.abs().gt(order.baseAssetAmountFilled)) {
+        return true;
+    }
+}
+exports.isOrderRiskIncreasing = isOrderRiskIncreasing;

package/lib/math/position.d.ts

@@ -1,5 +1,5 @@
 import BN from 'bn.js';
-import { Market, UserPosition } from '../types';
+import { Market, PositionDirection, UserPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -30,4 +30,6 @@ export declare function calculatePositionFundingPNL(market: Market, marketPositi
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
 export declare function calculateEntryPrice(userPosition: UserPosition): BN;
-//# sourceMappingURL=position.d.ts.map
+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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const bn_js_1 = __importDefault(require("bn.js"));
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -19,10 +19,8 @@ function calculateBaseAssetValue(market, userPosition) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    const directionToClose = userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.SHORT
-        : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
+    const directionToClose = findDirectionToClose(userPosition);
+    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', userPosition.baseAssetAmount.abs(), amm_1.getSwapDirection('base', directionToClose));
     switch (directionToClose) {
         case types_1.PositionDirection.SHORT:
             return market.amm.quoteAssetReserve
@@ -106,3 +104,19 @@ function calculateEntryPrice(userPosition) {
         .abs();
 }
 exports.calculateEntryPrice = calculateEntryPrice;
+function findDirectionToClose(userPosition) {
+    return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.SHORT
+        : types_1.PositionDirection.LONG;
+}
+exports.findDirectionToClose = findDirectionToClose;
+function positionCurrentDirection(userPosition) {
+    return userPosition.baseAssetAmount.gte(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.LONG
+        : types_1.PositionDirection.SHORT;
+}
+exports.positionCurrentDirection = positionCurrentDirection;
+function isEmptyPosition(userPosition) {
+    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
+}
+exports.isEmptyPosition = isEmptyPosition;

package/lib/math/trade.d.ts

@@ -45,4 +45,3 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  * ]
  */
 export declare function calculateTargetPriceTrade(market: Market, targetPrice: BN, pct?: BN, outputAssetType?: AssetType): [PositionDirection, BN, BN, BN];
-//# sourceMappingURL=trade.d.ts.map

package/lib/math/trade.js

@@ -25,18 +25,18 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
 function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote') {
-    const oldPrice = (0, market_1.calculateMarkPrice)(market);
+    const oldPrice = market_1.calculateMarkPrice(market);
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
     const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType);
-    const entryPrice = (0, amm_1.calculatePrice)(acquiredBase, acquiredQuote, market.amm.pegMultiplier).mul(new anchor_1.BN(-1));
-    const newPrice = (0, amm_1.calculatePrice)(market.amm.baseAssetReserve.sub(acquiredBase), market.amm.quoteAssetReserve.sub(acquiredQuote), market.amm.pegMultiplier);
+    const entryPrice = amm_1.calculatePrice(acquiredBase, acquiredQuote, market.amm.pegMultiplier).mul(new anchor_1.BN(-1));
+    const newPrice = amm_1.calculatePrice(market.amm.baseAssetReserve.sub(acquiredBase), market.amm.quoteAssetReserve.sub(acquiredQuote), market.amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
-        (0, assert_1.assert)(newPrice.lt(oldPrice));
+        assert_1.assert(newPrice.lt(oldPrice));
     }
     else {
-        (0, assert_1.assert)(oldPrice.lt(newPrice));
+        assert_1.assert(oldPrice.lt(newPrice));
     }
     const pctMaxSlippage = newPrice
         .sub(oldPrice)
@@ -64,7 +64,7 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
-    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, inputAssetType, amount, (0, amm_1.getSwapDirection)(inputAssetType, direction));
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, inputAssetType, amount, amm_1.getSwapDirection(inputAssetType, direction));
     const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
     return [acquiredBase, acquiredQuote];
@@ -86,10 +86,10 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * ]
  */
 function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote') {
-    (0, assert_1.assert)(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
-    (0, assert_1.assert)(targetPrice.gt(numericConstants_1.ZERO));
-    (0, assert_1.assert)(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
-    const markPriceBefore = (0, market_1.calculateMarkPrice)(market);
+    assert_1.assert(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
+    assert_1.assert(targetPrice.gt(numericConstants_1.ZERO));
+    assert_1.assert(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
+    const markPriceBefore = market_1.calculateMarkPrice(market);
     if (targetPrice.gt(markPriceBefore)) {
         const priceGap = targetPrice.sub(markPriceBefore);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
@@ -114,11 +114,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     let markPriceAfter;
     if (markPriceBefore.gt(targetPrice)) {
         // overestimate y2
-        baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
+        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
         quoteAssetReserveAfter = k
             .div(numericConstants_1.MARK_PRICE_PRECISION)
             .div(baseAssetReserveAfter);
-        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
             .sub(quoteAssetReserveAfter)
@@ -129,11 +129,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     else if (markPriceBefore.lt(targetPrice)) {
         // underestimate y2
-        baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
+        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
         quoteAssetReserveAfter = k
             .div(numericConstants_1.MARK_PRICE_PRECISION)
             .div(baseAssetReserveAfter);
-        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
             .sub(quoteAssetReserveBefore)
@@ -160,8 +160,8 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(baseSize.abs());
-    (0, assert_1.assert)(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
-    (0, assert_1.assert)(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
+    assert_1.assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
+    assert_1.assert(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
         tp2.toString() +
         '>=' +
         tp1.toString() +

package/lib/math/utils.d.ts

@@ -1,3 +1,2 @@
 /// <reference types="bn.js" />
 export declare const squareRootBN: (n: any, closeness?: import("bn.js")) => any;
-//# sourceMappingURL=utils.d.ts.map

package/lib/mockUSDCFaucet.d.ts

@@ -33,4 +33,3 @@ export declare class MockUSDCFaucet {
         callback: (accountInfo: AccountInfo) => void;
     }): Promise<boolean>;
 }
-//# sourceMappingURL=mockUSDCFaucet.d.ts.map

package/lib/orderParams.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="bn.js" />
+import { OrderParams, OrderTriggerCondition, PositionDirection } 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): OrderParams;
+export declare function getStopOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean): OrderParams;
+export declare function getStopLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean): OrderParams;
+export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;

package/lib/orderParams.js

@@ -0,0 +1,88 @@
+"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

@@ -0,0 +1,5 @@
+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;