@drift-labs/sdk 0.1.23-master.2 → 0.1.24

package/lib/idl/clearing_house.json

@@ -211,6 +211,18 @@
                 {
                     "name": "ammPegMultiplier",
                     "type": "u128"
+                },
+                {
+                    "name": "marginRatioInitial",
+                    "type": "u32"
+                },
+                {
+                    "name": "marginRatioPartial",
+                    "type": "u32"
+                },
+                {
+                    "name": "marginRatioMaintenance",
+                    "type": "u32"
                 }
             ]
         },
@@ -1526,22 +1538,31 @@
                 },
                 {
                     "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "markets",
                     "isMut": true,
                     "isSigner": false
                 }
             ],
             "args": [
+                {
+                    "name": "marketIndex",
+                    "type": "u64"
+                },
                 {
                     "name": "marginRatioInitial",
-                    "type": "u128"
+                    "type": "u32"
                 },
                 {
                     "name": "marginRatioPartial",
-                    "type": "u128"
+                    "type": "u32"
                 },
                 {
                     "name": "marginRatioMaintenance",
-                    "type": "u128"
+                    "type": "u32"
                 }
             ]
         },
@@ -3028,9 +3049,21 @@
                             "defined": "AMM"
                         }
                     },
+                    {
+                        "name": "marginRatioInitial",
+                        "type": "u32"
+                    },
+                    {
+                        "name": "marginRatioPartial",
+                        "type": "u32"
+                    },
+                    {
+                        "name": "marginRatioMaintenance",
+                        "type": "u32"
+                    },
                     {
                         "name": "padding0",
-                        "type": "u128"
+                        "type": "u32"
                     },
                     {
                         "name": "padding1",
@@ -4132,6 +4165,11 @@
             "code": 6056,
             "name": "NoPositionsLiquidatable",
             "msg": "No positions liquidatable"
+        },
+        {
+            "code": 6057,
+            "name": "InvalidMarginRatio",
+            "msg": "Invalid Margin Ratio"
         }
     ]
 }

package/lib/math/amm.js

@@ -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,10 +79,10 @@ exports.calculateSwapOutput = calculateSwapOutput;
  * @param positionDirection
  */
 function getSwapDirection(inputAssetType, positionDirection) {
-    if ((0, types_1.isVariant)(positionDirection, 'long') && inputAssetType === 'base') {
+    if (types_1.isVariant(positionDirection, 'long') && inputAssetType === 'base') {
         return types_1.SwapDirection.REMOVE;
     }
-    if ((0, types_1.isVariant)(positionDirection, 'short') && inputAssetType === 'quote') {
+    if (types_1.isVariant(positionDirection, 'short') && inputAssetType === 'quote') {
         return types_1.SwapDirection.REMOVE;
     }
     return types_1.SwapDirection.ADD;
@@ -104,7 +104,7 @@ function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
         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
@@ -115,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);
     const p = numericConstants_1.PEG_PRECISION.mul(numerator).div(denomenator);
     const x = market.amm.baseAssetReserve;
     const y = market.amm.quoteAssetReserve;
@@ -134,7 +134,7 @@ function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
         .sub(numer1)
         .mul(market.amm.pegMultiplier)
         .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-    console.log((0, __1.convertToNumber)(formulaCost, numericConstants_1.QUOTE_PRECISION));
+    console.log(__1.convertToNumber(formulaCost, numericConstants_1.QUOTE_PRECISION));
     // p.div(p.mul(x).add(delta)).sub()
     return cost;
 }
@@ -155,22 +155,22 @@ function calculateRepegCost(market, marketIndex, newPeg) {
         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);
     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((0, __1.convertToNumber)(cost2, numericConstants_1.QUOTE_PRECISION));
+    console.log(__1.convertToNumber(cost2, numericConstants_1.QUOTE_PRECISION));
     return cost;
 }
 exports.calculateRepegCost = calculateRepegCost;
@@ -200,7 +200,7 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price) {
         .mul(amm.pegMultiplier)
         .div(limit_price)
         .div(numericConstants_1.PEG_PRECISION);
-    const newBaseAssetReserve = (0, __1.squareRootBN)(newBaseAssetReserveSquared);
+    const newBaseAssetReserve = __1.squareRootBN(newBaseAssetReserveSquared);
     if (newBaseAssetReserve.gt(amm.baseAssetReserve)) {
         return [
             newBaseAssetReserve.sub(amm.baseAssetReserve),

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.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/market.js

@@ -9,11 +9,11 @@ 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] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', direction));
+    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;

package/lib/math/orders.d.ts

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

package/lib/math/orders.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrderRiskIncreasing = void 0;
+exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 function isOrderRiskIncreasing(user, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
+    if (types_1.isVariant(order.status, 'init')) {
         return false;
     }
     const position = user.getUserPosition(order.marketIndex) ||
@@ -14,12 +14,12 @@ function isOrderRiskIncreasing(user, order) {
         return true;
     }
     // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(order.direction, '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) &&
-        (0, types_1.isVariant)(order.direction, 'short')) {
+        types_1.isVariant(order.direction, 'short')) {
         return true;
     }
     const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
@@ -30,3 +30,43 @@ function isOrderRiskIncreasing(user, order) {
     return false;
 }
 exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
+function isOrderRiskIncreasingInSameDirection(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;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
+function isOrderReduceOnly(user, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return false;
+    }
+    const position = user.getUserPosition(order.marketIndex) ||
+        user.getEmptyPosition(order.marketIndex);
+    // if position is long and order is long
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
+        return false;
+    }
+    // if position is short and order is short
+    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
+        types_1.isVariant(order.direction, 'short')) {
+        return false;
+    }
+    return order.baseAssetAmount.abs().lte(position.baseAssetAmount.abs());
+}
+exports.isOrderReduceOnly = isOrderReduceOnly;

package/lib/math/position.js

@@ -17,7 +17,7 @@ function calculateBaseAssetValue(market, userPosition) {
         return numericConstants_1.ZERO;
     }
     const directionToClose = findDirectionToClose(userPosition);
-    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
+    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

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,11 +64,11 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
-    const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
-    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, inputAssetType, amount, swapDirection);
+    const swapDirection = amm_1.getSwapDirection(inputAssetType, direction);
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, inputAssetType, amount, swapDirection);
     const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
     let acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    if (inputAssetType === 'base' && (0, types_1.isVariant)(swapDirection, 'remove')) {
+    if (inputAssetType === 'base' && types_1.isVariant(swapDirection, 'remove')) {
         acquiredQuote = acquiredQuote.sub(numericConstants_1.ONE);
     }
     return [acquiredBase, acquiredQuote];
@@ -90,10 +90,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);
@@ -118,11 +118,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)
@@ -133,11 +133,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)
@@ -164,8 +164,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/orders.d.ts

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

package/lib/orders.js

@@ -1,26 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateBaseAssetAmountUserCanExecute = exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
+const _1 = require(".");
 const market_1 = require("./math/market");
 const numericConstants_1 = require("./constants/numericConstants");
 const amm_1 = require("./math/amm");
 const position_1 = require("./math/position");
 function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if ((0, types_1.isVariant)(order.status, 'init')) {
+    if (types_1.isVariant(order.status, 'init')) {
         return null;
     }
-    const baseAssetAmountToTrade = calculateAmountToTrade(market, order);
+    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
     if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
         return null;
     }
     const userAccountAfter = Object.assign({}, userAccount);
     const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = (0, position_1.positionCurrentDirection)(userPosition);
+    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
     const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
         isSameDirection(order.direction, currentPositionDirection);
     if (increasePosition) {
-        const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
+        const 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);
@@ -29,10 +30,10 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
     else {
         const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
         if (reversePosition) {
-            const intermediateMarket = (0, market_1.calculateNewMarketAfterTrade)(userPosition.baseAssetAmount, (0, position_1.findDirectionToClose)(userPosition), market);
+            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
             const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
             let pnl;
-            if ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
+            if (types_1.isVariant(currentPositionDirection, 'long')) {
                 pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
             }
             else {
@@ -40,20 +41,20 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
             }
             userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
             const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountLeft, order.direction, intermediateMarket);
+            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 = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
+            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 ((0, types_1.isVariant)(currentPositionDirection, 'long')) {
+            if (types_1.isVariant(currentPositionDirection, 'long')) {
                 pnl = baseAssetValue.sub(costBasisRealized);
             }
             else {
@@ -79,14 +80,14 @@ function calculateAmountSwapped(marketBefore, marketAfter) {
         baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
     };
 }
-function calculateAmountToTrade(market, order) {
-    if ((0, types_1.isVariant)(order.orderType, 'limit')) {
+function calculateBaseAssetAmountMarketCanExecute(market, order) {
+    if (types_1.isVariant(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order);
     }
-    else if ((0, types_1.isVariant)(order.orderType, 'triggerLimit')) {
+    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
-    else if ((0, types_1.isVariant)(order.orderType, 'market')) {
+    else if (types_1.isVariant(order.orderType, 'market')) {
         // should never be a market order queued
         return numericConstants_1.ZERO;
     }
@@ -94,8 +95,9 @@ function calculateAmountToTrade(market, order) {
         return calculateAmountToTradeForTriggerMarket(market, order);
     }
 }
+exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
 function calculateAmountToTradeForLimit(market, order) {
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, order.price);
+    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, order.price);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {
@@ -117,8 +119,8 @@ function calculateAmountToTradeForTriggerLimit(market, order) {
 }
 exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
 function isSameDirection(firstDirection, secondDirection) {
-    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
-        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
+    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)
@@ -126,11 +128,37 @@ function calculateAmountToTradeForTriggerMarket(market, order) {
         : numericConstants_1.ZERO;
 }
 function isTriggerConditionSatisfied(market, order) {
-    const markPrice = (0, market_1.calculateMarkPrice)(market);
-    if ((0, types_1.isVariant)(order.triggerCondition, 'above')) {
+    const markPrice = market_1.calculateMarkPrice(market);
+    if (types_1.isVariant(order.triggerCondition, 'above')) {
         return markPrice.gt(order.triggerPrice);
     }
     else {
         return markPrice.lt(order.triggerPrice);
     }
 }
+function calculateBaseAssetAmountUserCanExecute(market, order, user) {
+    const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
+    const freeCollateral = user.getFreeCollateral();
+    let quoteAssetAmount;
+    if (_1.isOrderRiskIncreasingInSameDirection(user, order)) {
+        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
+    }
+    else {
+        const position = user.getUserPosition(order.marketIndex) ||
+            user.getEmptyPosition(order.marketIndex);
+        const positionValue = _1.calculateBaseAssetValue(market, position);
+        quoteAssetAmount = freeCollateral
+            .mul(maxLeverage)
+            .div(_1.TEN_THOUSAND)
+            .add(positionValue.mul(numericConstants_1.TWO));
+    }
+    if (quoteAssetAmount.lte(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const baseAssetReservesBefore = market.amm.baseAssetReserve;
+    const [_, baseAssetReservesAfter] = _1.calculateAmmReservesAfterSwap(market.amm, 'quote', quoteAssetAmount, types_1.isVariant(order.direction, 'long')
+        ? types_1.SwapDirection.ADD
+        : types_1.SwapDirection.REMOVE);
+    return baseAssetReservesBefore.sub(baseAssetReservesAfter).abs();
+}
+exports.calculateBaseAssetAmountUserCanExecute = calculateBaseAssetAmountUserCanExecute;

package/lib/pythClient.js

@@ -18,7 +18,7 @@ class PythClient {
     getPriceData(pricePublicKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const account = yield this.connection.getAccountInfo(pricePublicKey);
-            return (0, client_1.parsePriceData)(account.data);
+            return client_1.parsePriceData(account.data);
         });
     }
 }

package/lib/tx/retryTxSender.js

@@ -93,7 +93,7 @@ class RetryTxSender {
             catch (err) {
                 throw new Error('signature must be base58 encoded: ' + signature);
             }
-            (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+            assert_1.default(decodedSignature.length === 64, 'signature has invalid length');
             const start = Date.now();
             const subscriptionCommitment = commitment || this.provider.opts.commitment;
             let subscriptionId;

package/lib/types.d.ts

@@ -272,7 +272,6 @@ export declare type OrderStateAccount = {
     minOrderQuoteAssetAmount: BN;
 };
 export declare type MarketsAccount = {
-    accountIndex: BN;
     markets: Market[];
 };
 export declare type Market = {
@@ -282,6 +281,9 @@ export declare type Market = {
     baseAssetAmountShort: BN;
     initialized: boolean;
     openInterest: BN;
+    marginRatioInitial: number;
+    marginRatioMaintenance: number;
+    marginRatioPartial: number;
 };
 export declare type AMM = {
     baseAssetReserve: BN;
@@ -434,3 +436,4 @@ export declare type OrderFillerRewardStructure = {
     rewardDenominator: BN;
     timeBasedRewardLowerBound: BN;
 };
+export declare type MarginCategory = 'Initial' | 'Partial' | 'Maintenance';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.23-master.2",
+	"version": "0.1.24",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",