@drift-labs/sdk 0.1.20 → 0.1.21-master.5

package/lib/index.d.ts

@@ -22,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';
@@ -30,4 +33,3 @@ export * from './constants/numericConstants';
 export * from './util/computeUnits';
 export * from './util/tps';
 export { BN, PublicKey };
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -37,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,6 @@ 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];
+export declare function calculateBudgetedK(market: Market, cost: BN): [BN, BN];
+export declare function calculateBudgetedPeg(market: Market, cost: BN): BN;

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.calculateBudgetedPeg = exports.calculateBudgetedK = 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");
@@ -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,6 +102,7 @@ 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 = position_1.calculateBaseAssetValue(market, netUserPosition);
     const marketNewK = Object.assign({}, market);
@@ -117,6 +116,26 @@ function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
     marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
     netUserPosition.quoteAssetAmount = currentValue;
     const cost = __1.calculatePositionPNL(marketNewK, netUserPosition);
+    const p = numericConstants_1.PEG_PRECISION.mul(numerator).div(denomenator);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const delta = market.baseAssetAmount;
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const numer1 = numericConstants_1.PEG_PRECISION.sub(p).mul(y).div(numericConstants_1.PEG_PRECISION);
+    const numer20 = k
+        .mul(p)
+        .mul(p)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PEG_PRECISION).add(delta));
+    const numer21 = k.div(x.add(delta));
+    const formulaCost = numer21
+        .sub(numer20)
+        .sub(numer1)
+        .mul(market.amm.pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log(__1.convertToNumber(formulaCost, numericConstants_1.QUOTE_PRECISION));
+    // p.div(p.mul(x).add(delta)).sub()
     return cost;
 }
 exports.calculateAdjustKCost = calculateAdjustKCost;
@@ -134,6 +153,7 @@ 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 = position_1.calculateBaseAssetValue(market, netUserPosition);
     netUserPosition.quoteAssetAmount = currentValue;
@@ -144,6 +164,13 @@ function calculateRepegCost(market, marketIndex, newPeg) {
     marketNewPeg.amm.pegMultiplier = newPeg;
     console.log('Price moves from', __1.convertToNumber(prevMarketPrice), 'to', __1.convertToNumber(__1.calculateMarkPrice(marketNewPeg)));
     const cost = __1.calculatePositionPNL(marketNewPeg, netUserPosition);
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const newQuoteAssetReserve = k.div(market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount));
+    const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(market.amm.quoteAssetReserve);
+    const cost2 = deltaQuoteAssetReserves
+        .mul(market.amm.pegMultiplier.sub(newPeg))
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log(__1.convertToNumber(cost2, numericConstants_1.QUOTE_PRECISION));
     return cost;
 }
 exports.calculateRepegCost = calculateRepegCost;
@@ -154,9 +181,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 +193,92 @@ 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;
+function calculateBudgetedK(market, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const numer1 = y.mul(d).mul(Q).div(numericConstants_1.AMM_RESERVE_PRECISION).div(numericConstants_1.PEG_PRECISION);
+    const numer2 = C.mul(x.add(d)).div(numericConstants_1.QUOTE_PRECISION);
+    const denom1 = C.mul(x)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    const denom2 = y
+        .mul(d)
+        .mul(d)
+        .mul(Q)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION);
+    const numerator = d
+        .mul(numer1.add(numer2))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    const denominator = denom1
+        .add(denom2)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    console.log(numerator, denominator);
+    // const p = (numerator).div(denominator);
+    // const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+    // console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(market, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO))
+        .mul(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    console.log(Q.toNumber(), 'change by', deltaPegMultiplier.toNumber() / numericConstants_1.MARK_PRICE_PRECISION.toNumber());
+    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/conversion.d.ts

@@ -1,4 +1,3 @@
 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/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/insuranceFund.d.ts

@@ -13,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/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
@@ -12,3 +12,13 @@ function calculateMarkPrice(market) {
     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,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '../';
-import { Market, UserPosition } from '../types';
+import { Market, PositionDirection, UserPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -31,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,6 +1,6 @@
 "use strict";
 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 __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -16,9 +16,7 @@ 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 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:
@@ -103,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/utils.d.ts

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

package/lib/mockUSDCFaucet.d.ts

@@ -34,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;

package/lib/orderParams.js

@@ -0,0 +1,108 @@
+"use strict";
+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) {
+    return {
+        orderType: types_1.OrderType.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: types_1.OrderTriggerCondition.ABOVE,
+        triggerPrice: numericConstants_1.ZERO,
+        oraclePriceOffset: numericConstants_1.ZERO,
+    };
+}
+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,
+    };
+}
+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,
+    };
+}
+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,
+    };
+}
+exports.getMarketOrderParams = getMarketOrderParams;

package/lib/orders.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="bn.js" />
+import { Market, Order, UserAccount, UserPosition } from './types';
+import { BN } from '.';
+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 calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;

package/lib/orders.js

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

package/lib/pythClient.d.ts

@@ -5,4 +5,3 @@ export declare class PythClient {
     constructor(connection: Connection);
     getPriceData(pricePublicKey: PublicKey): Promise<PriceData>;
 }
-//# sourceMappingURL=pythClient.d.ts.map

package/lib/token/index.d.ts

@@ -1,4 +1,3 @@
 /// <reference types="node" />
 import { AccountInfo } from '@solana/spl-token';
 export declare function parseTokenAccount(data: Buffer): AccountInfo;
-//# sourceMappingURL=index.d.ts.map