@drift-labs/sdk 0.1.23-master.0 → 0.1.23-master.4

package/lib/idl/clearing_house.json

@@ -1321,6 +1321,52 @@
                 }
             ]
         },
+        {
+            "name": "initializeUserOrdersWithExplicitPayer",
+            "accounts": [
+                {
+                    "name": "user",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "userOrders",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "payer",
+                    "isMut": true,
+                    "isSigner": true
+                },
+                {
+                    "name": "rent",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "systemProgram",
+                    "isMut": false,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "userOrdersNonce",
+                    "type": "u8"
+                }
+            ]
+        },
         {
             "name": "deleteUser",
             "accounts": [
@@ -3667,6 +3713,23 @@
                 ]
             }
         },
+        {
+            "name": "LiquidationType",
+            "type": {
+                "kind": "enum",
+                "variants": [
+                    {
+                        "name": "NONE"
+                    },
+                    {
+                        "name": "PARTIAL"
+                    },
+                    {
+                        "name": "FULL"
+                    }
+                ]
+            }
+        },
         {
             "name": "OracleSource",
             "type": {
@@ -4064,6 +4127,11 @@
             "code": 6055,
             "name": "UserOrderIdAlreadyInUse",
             "msg": "User Order Id Already In Use"
+        },
+        {
+            "code": 6056,
+            "name": "NoPositionsLiquidatable",
+            "msg": "No positions liquidatable"
         }
     ]
 }

package/lib/index.d.ts

@@ -6,6 +6,7 @@ export * from './types';
 export * from './constants/markets';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
+export * from './accounts/bulkUserSubscription';
 export * from './accounts/pollingClearingHouseAccountSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/types';
@@ -30,6 +31,7 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
 export { BN, PublicKey };

package/lib/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./constants/markets"), exports);
 __exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), exports);
 __exportStar(require("./accounts/bulkAccountLoader"), exports);
+__exportStar(require("./accounts/bulkUserSubscription"), exports);
 __exportStar(require("./accounts/pollingClearingHouseAccountSubscriber"), exports);
 __exportStar(require("./accounts/pollingTokenAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
@@ -45,5 +46,6 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./math/utils"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./constants/numericConstants"), exports);
+__exportStar(require("./tx/retryTxSender"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);

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) {
-    assert_1.assert(swapAmount.gte(numericConstants_1.ZERO), 'swapAmount must be greater than 0');
+    (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 (types_1.isVariant(positionDirection, 'long') && inputAssetType === 'base') {
+    if ((0, types_1.isVariant)(positionDirection, 'long') && inputAssetType === 'base') {
         return types_1.SwapDirection.REMOVE;
     }
-    if (types_1.isVariant(positionDirection, 'short') && inputAssetType === 'quote') {
+    if ((0, 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 = position_1.calculateBaseAssetValue(market, netUserPosition);
+    const currentValue = (0, 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 = __1.calculatePositionPNL(marketNewK, netUserPosition);
+    const cost = (0, __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(__1.convertToNumber(formulaCost, numericConstants_1.QUOTE_PRECISION));
+    console.log((0, __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 = position_1.calculateBaseAssetValue(market, netUserPosition);
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
     netUserPosition.quoteAssetAmount = currentValue;
-    const prevMarketPrice = __1.calculateMarkPrice(market);
+    const prevMarketPrice = (0, __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', __1.convertToNumber(prevMarketPrice), 'to', __1.convertToNumber(__1.calculateMarkPrice(marketNewPeg)));
-    const cost = __1.calculatePositionPNL(marketNewPeg, netUserPosition);
+    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
+    const cost = (0, __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));
+    console.log((0, __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 = __1.squareRootBN(newBaseAssetReserveSquared);
+    const newBaseAssetReserve = (0, __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 exports.convertToNumber(baseAssetAmount, numericConstants_1.MARK_PRICE_PRECISION.mul(numericConstants_1.PEG_PRECISION));
+    return (0, 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 = market_1.calculateMarkPrice(market);
+        const baseAssetPriceWithMantissa = (0, 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 amm_1.calculatePrice(market.amm.baseAssetReserve, market.amm.quoteAssetReserve, market.amm.pegMultiplier);
+    return (0, 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 [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', baseAssetAmount.abs(), (0, 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,4 @@
 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;

package/lib/math/orders.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrderRiskIncreasing = void 0;
+exports.isOrderRiskIncreasingInSameDirection = 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')) {
+    if ((0, 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) && types_1.isVariant(order.direction, 'long')) {
+    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && (0, 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')) {
+        (0, types_1.isVariant)(order.direction, 'short')) {
         return true;
     }
     const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
@@ -30,3 +30,25 @@ function isOrderRiskIncreasing(user, order) {
     return false;
 }
 exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
+function isOrderRiskIncreasingInSameDirection(user, order) {
+    if ((0, 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) && (0, 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')) {
+        return true;
+    }
+    return false;
+}
+exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;

package/lib/math/position.js

@@ -17,7 +17,7 @@ function calculateBaseAssetValue(market, userPosition) {
         return numericConstants_1.ZERO;
     }
     const directionToClose = findDirectionToClose(userPosition);
-    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', userPosition.baseAssetAmount.abs(), amm_1.getSwapDirection('base', directionToClose));
+    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
     switch (directionToClose) {
         case types_1.PositionDirection.SHORT:
             return market.amm.quoteAssetReserve
@@ -28,7 +28,8 @@ function calculateBaseAssetValue(market, userPosition) {
             return newQuoteAssetReserve
                 .sub(market.amm.quoteAssetReserve)
                 .mul(market.amm.pegMultiplier)
-                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+                .add(numericConstants_1.ONE);
     }
 }
 exports.calculateBaseAssetValue = calculateBaseAssetValue;
@@ -50,7 +51,7 @@ function calculatePositionPNL(market, marketPosition, withFunding = false) {
         pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
     }
     else {
-        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue).sub(numericConstants_1.ONE);
+        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
     }
     if (withFunding) {
         const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);

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 = market_1.calculateMarkPrice(market);
+    const oldPrice = (0, 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 = 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);
+    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);
     if (direction == types_1.PositionDirection.SHORT) {
-        assert_1.assert(newPrice.lt(oldPrice));
+        (0, assert_1.assert)(newPrice.lt(oldPrice));
     }
     else {
-        assert_1.assert(oldPrice.lt(newPrice));
+        (0, assert_1.assert)(oldPrice.lt(newPrice));
     }
     const pctMaxSlippage = newPrice
         .sub(oldPrice)
@@ -64,9 +64,13 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
-    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, inputAssetType, amount, amm_1.getSwapDirection(inputAssetType, direction));
+    const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
+    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(market.amm, inputAssetType, amount, swapDirection);
     const acquiredBase = market.amm.baseAssetReserve.sub(newBaseAssetReserve);
-    const acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+    let acquiredQuote = market.amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+    if (inputAssetType === 'base' && (0, types_1.isVariant)(swapDirection, 'remove')) {
+        acquiredQuote = acquiredQuote.sub(numericConstants_1.ONE);
+    }
     return [acquiredBase, acquiredQuote];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
@@ -86,10 +90,10 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * ]
  */
 function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote') {
-    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);
+    (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);
     if (targetPrice.gt(markPriceBefore)) {
         const priceGap = targetPrice.sub(markPriceBefore);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
@@ -114,11 +118,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     let markPriceAfter;
     if (markPriceBefore.gt(targetPrice)) {
         // overestimate y2
-        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
+        baseAssetReserveAfter = (0, 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 = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
             .sub(quoteAssetReserveAfter)
@@ -129,11 +133,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     else if (markPriceBefore.lt(targetPrice)) {
         // underestimate y2
-        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
+        baseAssetReserveAfter = (0, 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 = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
             .sub(quoteAssetReserveBefore)
@@ -160,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());
-    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' +
+    (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' +
         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 (types_1.isVariant(order.status, 'init')) {
+    if ((0, 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 = position_1.positionCurrentDirection(userPosition);
+    const currentPositionDirection = (0, 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 marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
         const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
         userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
         userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
@@ -29,10 +30,10 @@ function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
     else {
         const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
         if (reversePosition) {
-            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
+            const intermediateMarket = (0, market_1.calculateNewMarketAfterTrade)(userPosition.baseAssetAmount, (0, position_1.findDirectionToClose)(userPosition), market);
             const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
             let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
+            if ((0, 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 = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
+            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountLeft, order.direction, intermediateMarket);
             const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
             userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
             userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
             return [userAccountAfter, userPositionAfter, marketAfter];
         }
         else {
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+            const marketAfter = (0, market_1.calculateNewMarketAfterTrade)(baseAssetAmountToTrade, order.direction, market);
             const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
             const costBasisRealized = userPosition.quoteAssetAmount
                 .mul(baseAssetAmountSwapped.abs())
                 .div(userPosition.baseAssetAmount.abs());
             let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
+            if ((0, 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 (types_1.isVariant(order.orderType, 'limit')) {
+function calculateBaseAssetAmountMarketCanExecute(market, order) {
+    if ((0, types_1.isVariant)(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order);
     }
-    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
+    else if ((0, types_1.isVariant)(order.orderType, 'triggerLimit')) {
         return calculateAmountToTradeForTriggerLimit(market, order);
     }
-    else if (types_1.isVariant(order.orderType, 'market')) {
+    else if ((0, 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] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, order.price);
+    const [maxAmountToTrade, direction] = (0, 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 ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
-        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
+    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')));
 }
 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 = market_1.calculateMarkPrice(market);
-    if (types_1.isVariant(order.triggerCondition, 'above')) {
+    const markPrice = (0, market_1.calculateMarkPrice)(market);
+    if ((0, 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('Initial');
+    const freeCollateral = user.getFreeCollateral();
+    let quoteAssetAmount;
+    if ((0, _1.isOrderRiskIncreasingInSameDirection)(user, order)) {
+        quoteAssetAmount = freeCollateral.mul(maxLeverage).div(_1.TEN_THOUSAND);
+    }
+    else {
+        const position = user.getUserPosition(order.marketIndex) ||
+            user.getEmptyPosition(order.marketIndex);
+        const positionValue = (0, _1.calculateBaseAssetValue)(market, position);
+        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] = (0, _1.calculateAmmReservesAfterSwap)(market.amm, 'quote', quoteAssetAmount, (0, 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 client_1.parsePriceData(account.data);
+            return (0, client_1.parsePriceData)(account.data);
         });
     }
 }

package/lib/tx/retryTxSender.d.ts

@@ -0,0 +1,19 @@
+import { TxSender } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature } from '@solana/web3.js';
+import { Provider } from '@project-serum/anchor';
+declare type ResolveReference = {
+    resolve?: () => void;
+};
+export declare class RetryTxSender implements TxSender {
+    provider: Provider;
+    timeout: number;
+    retrySleep: number;
+    constructor(provider: Provider, timeout?: number, retrySleep?: number);
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
+    confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getTimestamp(): number;
+    sleep(reference: ResolveReference): Promise<void>;
+    promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null>;
+}
+export {};