@drift-labs/sdk 0.1.19-master.1 → 0.1.21-master.3

package/lib/index.d.ts

@@ -1,14 +1,20 @@
 import { BN } from '@project-serum/anchor';
+import { PublicKey } from '@solana/web3.js';
 export * from './mockUSDCFaucet';
 export * from './pythClient';
 export * from './types';
 export * from './constants/markets';
-export * from './accounts/defaultClearingHouseAccountSubscriber';
+export * from './accounts/webSocketClearingHouseAccountSubscriber';
+export * from './accounts/bulkAccountLoader';
+export * from './accounts/pollingClearingHouseAccountSubscriber';
+export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses';
 export * from './admin';
 export * from './clearingHouseUser';
 export * from './clearingHouse';
+export * from './factory/clearingHouse';
+export * from './factory/clearingHouseUser';
 export * from './math/conversion';
 export * from './math/funding';
 export * from './math/insuranceFund';
@@ -16,6 +22,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';
@@ -23,5 +32,4 @@ export * from './config';
 export * from './constants/numericConstants';
 export * from './util/computeUnits';
 export * from './util/tps';
-export { BN };
-//# sourceMappingURL=index.d.ts.map
+export { BN, PublicKey };

package/lib/index.js

@@ -10,19 +10,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BN = void 0;
+exports.PublicKey = exports.BN = void 0;
 const anchor_1 = require("@project-serum/anchor");
 Object.defineProperty(exports, "BN", { enumerable: true, get: function () { return anchor_1.BN; } });
+const web3_js_1 = require("@solana/web3.js");
+Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return web3_js_1.PublicKey; } });
 __exportStar(require("./mockUSDCFaucet"), exports);
 __exportStar(require("./pythClient"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants/markets"), exports);
-__exportStar(require("./accounts/defaultClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/bulkAccountLoader"), exports);
+__exportStar(require("./accounts/pollingClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/pollingTokenAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
 __exportStar(require("./addresses"), exports);
 __exportStar(require("./admin"), exports);
 __exportStar(require("./clearingHouseUser"), exports);
 __exportStar(require("./clearingHouse"), exports);
+__exportStar(require("./factory/clearingHouse"), exports);
+__exportStar(require("./factory/clearingHouseUser"), exports);
 __exportStar(require("./math/conversion"), exports);
 __exportStar(require("./math/funding"), exports);
 __exportStar(require("./math/insuranceFund"), exports);
@@ -30,6 +37,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';
+import { BN } from '../';
 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

@@ -1,5 +1,6 @@
+/// <reference types="bn.js" />
 import { MarketsAccount, StateAccount } from '../types';
-import BN from 'bn.js';
+import { BN } from '../';
 import { Connection } from '@solana/web3.js';
 /**
  * In the case of a levered loss, the exchange first pays out undistributed fees and then the insurance fund.
@@ -12,4 +13,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/insuranceFund.js

@@ -8,12 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateInsuranceFundSize = void 0;
-const bn_js_1 = __importDefault(require("bn.js"));
+const __1 = require("../");
 /**
  * In the case of a levered loss, the exchange first pays out undistributed fees and then the insurance fund.
  * Thus the de facto size of the insurance fund is the amount in the insurance vault plus the sum of each markets
@@ -27,9 +24,9 @@ const bn_js_1 = __importDefault(require("bn.js"));
 function calculateInsuranceFundSize(connection, state, marketsAccount) {
     return __awaiter(this, void 0, void 0, function* () {
         const insuranceVaultPublicKey = state.insuranceVault;
-        const insuranceVaultAmount = new bn_js_1.default((yield connection.getTokenAccountBalance(insuranceVaultPublicKey)).value.amount);
+        const insuranceVaultAmount = new __1.BN((yield connection.getTokenAccountBalance(insuranceVaultPublicKey)).value.amount);
         return marketsAccount.markets.reduce((insuranceVaultAmount, market) => {
-            return insuranceVaultAmount.add(market.amm.totalFee.div(new bn_js_1.default(2)));
+            return insuranceVaultAmount.add(market.amm.totalFee.div(new __1.BN(2)));
         }, insuranceVaultAmount);
     });
 }

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,32 @@
+"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;
+    }
+    const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
+    // if order will flip position
+    if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(numericConstants_1.TWO))) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasing = isOrderRiskIncreasing;

package/lib/math/position.d.ts

@@ -1,5 +1,6 @@
-import BN from 'bn.js';
-import { Market, UserPosition } from '../types';
+/// <reference types="bn.js" />
+import { BN } from '../';
+import { Market, PositionDirection, UserPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -30,4 +31,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

@@ -1,10 +1,7 @@
 "use strict";
-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;
-const bn_js_1 = __importDefault(require("bn.js"));
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = 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");
@@ -19,10 +16,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
@@ -86,7 +81,7 @@ function calculatePositionFundingPNL(market, marketPosition) {
         .mul(marketPosition.baseAssetAmount)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
-        .mul(new bn_js_1.default(-1));
+        .mul(new __1.BN(-1));
     return perPositionFundingRate;
 }
 exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
@@ -106,3 +101,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,3 @@
 /// <reference types="bn.js" />
-export declare const squareRootBN: (n: any, closeness?: import("bn.js")) => any;
-//# sourceMappingURL=utils.d.ts.map
+import { BN } from '../';
+export declare const squareRootBN: (n: any, closeness?: BN) => any;

package/lib/math/utils.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.squareRootBN = void 0;
-const bn_js_1 = require("bn.js");
-const squareRootBN = (n, closeness = new bn_js_1.BN(1)) => {
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
     // Assuming the sqrt of n as n only
     let x = n;
     // The closed guess will be stored in the root
     let root;
     // To count the number of iterations
     let count = 0;
-    const TWO = new bn_js_1.BN(2);
+    const TWO = new __1.BN(2);
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     while (count < Number.MAX_SAFE_INTEGER) {
         count++;

package/lib/mockUSDCFaucet.d.ts

@@ -1,8 +1,9 @@
+/// <reference types="bn.js" />
 import * as anchor from '@project-serum/anchor';
 import { Program, Provider } from '@project-serum/anchor';
 import { AccountInfo } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
-import BN from 'bn.js';
+import { BN } from '.';
 import { IWallet } from './types';
 export declare class MockUSDCFaucet {
     connection: Connection;
@@ -33,4 +34,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, userOrderId?: number): 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;