@drift-labs/sdk 0.2.0-master.32 → 0.2.0-master.34

package/lib/index.d.ts

@@ -33,6 +33,7 @@ export * from './events/fetchLogs';
 export * from './math/auction';
 export * from './math/spotMarket';
 export * from './math/conversion';
+export * from './math/exchangeStatus';
 export * from './math/funding';
 export * from './math/market';
 export * from './math/position';
@@ -51,9 +52,11 @@ export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
 export * from './serum/serumSubscriber';
+export * from './serum/serumFulfillmentConfigMap';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
+export * from './util/promiseTimeout';
 export * from './math/spotBalance';
 export * from './constants/spotMarkets';
 export * from './clearingHouseConfig';

package/lib/index.js

@@ -56,6 +56,7 @@ __exportStar(require("./events/fetchLogs"), exports);
 __exportStar(require("./math/auction"), exports);
 __exportStar(require("./math/spotMarket"), exports);
 __exportStar(require("./math/conversion"), exports);
+__exportStar(require("./math/exchangeStatus"), exports);
 __exportStar(require("./math/funding"), exports);
 __exportStar(require("./math/market"), exports);
 __exportStar(require("./math/position"), exports);
@@ -74,9 +75,11 @@ __exportStar(require("./math/utils"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./constants/numericConstants"), exports);
 __exportStar(require("./serum/serumSubscriber"), exports);
+__exportStar(require("./serum/serumFulfillmentConfigMap"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);
+__exportStar(require("./util/promiseTimeout"), exports);
 __exportStar(require("./math/spotBalance"), exports);
 __exportStar(require("./constants/spotMarkets"), exports);
 __exportStar(require("./clearingHouseConfig"), exports);

package/lib/math/amm.js

@@ -62,10 +62,10 @@ function calculateNewAmm(amm, oraclePriceData) {
         newAmm.sqrtK = newAmm.sqrtK.mul(pKNumer).div(pKDenom);
         const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
         newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
-        const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+        const directionToClose = amm.baseAssetAmountWithAmm.gt(numericConstants_1.ZERO)
             ? types_1.PositionDirection.SHORT
             : types_1.PositionDirection.LONG;
-        const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+        const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.baseAssetAmountWithAmm.abs(), getSwapDirection('base', directionToClose));
         newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
         newPeg = (0, repeg_1.calculateBudgetedPeg)(newAmm, prePegCost, targetPrice);
         prePegCost = (0, repeg_1.calculateRepegCost)(newAmm, newPeg);
@@ -84,10 +84,10 @@ function calculateUpdatedAMM(amm, oraclePriceData) {
     const invariant = newAmm.sqrtK.mul(newAmm.sqrtK);
     newAmm.quoteAssetReserve = invariant.div(newAmm.baseAssetReserve);
     newAmm.pegMultiplier = newPeg;
-    const directionToClose = amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+    const directionToClose = amm.baseAssetAmountWithAmm.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT
         : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+    const [newQuoteAssetReserve, _newBaseAssetReserve] = calculateAmmReservesAfterSwap(newAmm, 'base', amm.baseAssetAmountWithAmm.abs(), getSwapDirection('base', directionToClose));
     newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
     newAmm.totalFeeMinusDistributions =
         newAmm.totalFeeMinusDistributions.sub(prepegCost);
@@ -278,7 +278,7 @@ function calculateSpread(amm, direction, oraclePriceData) {
     const confIntervalPct = confInterval
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(reservePrice);
-    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, reservePrice, amm.totalFeeMinusDistributions, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
+    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.baseAssetAmountWithAmm, reservePrice, amm.totalFeeMinusDistributions, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
     let spread;
     if ((0, types_1.isVariant)(direction, 'long')) {
         spread = longSpread;
@@ -356,10 +356,10 @@ exports.getSwapDirection = getSwapDirection;
  * @returns cost : Precision PRICE_PRECISION
  */
 function calculateTerminalPrice(market) {
-    const directionToClose = market.amm.netBaseAssetAmount.gt(numericConstants_1.ZERO)
+    const directionToClose = market.amm.baseAssetAmountWithAmm.gt(numericConstants_1.ZERO)
         ? types_1.PositionDirection.SHORT
         : types_1.PositionDirection.LONG;
-    const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.netBaseAssetAmount.abs(), getSwapDirection('base', directionToClose));
+    const [newQuoteAssetReserve, newBaseAssetReserve] = calculateAmmReservesAfterSwap(market.amm, 'base', market.amm.baseAssetAmountWithAmm.abs(), getSwapDirection('base', directionToClose));
     const terminalPrice = newQuoteAssetReserve
         .mul(numericConstants_1.PRICE_PRECISION)
         .mul(market.amm.pegMultiplier)
@@ -409,7 +409,7 @@ function calculateQuoteAssetAmountSwapped(quoteAssetReserves, pegMultiplier, swa
 }
 exports.calculateQuoteAssetAmountSwapped = calculateQuoteAssetAmountSwapped;
 function calculateMaxBaseAssetAmountFillable(amm, orderDirection) {
-    const maxFillSize = amm.baseAssetReserve.div(new anchor_1.BN(amm.maxBaseAssetAmountRatio));
+    const maxFillSize = amm.baseAssetReserve.div(new anchor_1.BN(amm.maxFillReserveFraction));
     let maxBaseAssetAmountOnSide;
     if ((0, types_1.isVariant)(orderDirection, 'long')) {
         maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.baseAssetReserve.sub(amm.minBaseAssetReserve));
@@ -417,6 +417,6 @@ function calculateMaxBaseAssetAmountFillable(amm, orderDirection) {
     else {
         maxBaseAssetAmountOnSide = anchor_1.BN.max(numericConstants_1.ZERO, amm.maxBaseAssetReserve.sub(amm.baseAssetReserve));
     }
-    return (0, __1.standardizeBaseAssetAmount)(anchor_1.BN.min(maxFillSize, maxBaseAssetAmountOnSide), amm.baseAssetAmountStepSize);
+    return (0, __1.standardizeBaseAssetAmount)(anchor_1.BN.min(maxFillSize, maxBaseAssetAmountOnSide), amm.orderStepSize);
 }
 exports.calculateMaxBaseAssetAmountFillable = calculateMaxBaseAssetAmountFillable;

package/lib/math/exchangeStatus.d.ts

@@ -0,0 +1,4 @@
+import { PerpMarketAccount, SpotMarketAccount, StateAccount } from '../types';
+export declare function exchangePaused(state: StateAccount): boolean;
+export declare function fillPaused(state: StateAccount, market: PerpMarketAccount | SpotMarketAccount): boolean;
+export declare function ammPaused(state: StateAccount, market: PerpMarketAccount | SpotMarketAccount): boolean;

package/lib/math/exchangeStatus.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ammPaused = exports.fillPaused = exports.exchangePaused = void 0;
+const types_1 = require("../types");
+function exchangePaused(state) {
+    return (0, types_1.isVariant)(state.exchangeStatus, 'paused');
+}
+exports.exchangePaused = exchangePaused;
+function fillPaused(state, market) {
+    return ((0, types_1.isOneOfVariant)(state.exchangeStatus, ['paused', 'fillPaused']) ||
+        (0, types_1.isOneOfVariant)(market.status, ['paused', 'fillPaused']));
+}
+exports.fillPaused = fillPaused;
+function ammPaused(state, market) {
+    return ((0, types_1.isOneOfVariant)(state.exchangeStatus, ['paused', 'ammPaused']) ||
+        (0, types_1.isOneOfVariant)(market.status, ['paused', 'ammPaused']));
+}
+exports.ammPaused = ammPaused;

package/lib/math/funding.js

@@ -90,9 +90,9 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     let cappedAltEst;
     let largerSide;
     let smallerSide;
-    if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
-        largerSide = market.baseAssetAmountLong.abs();
-        smallerSide = market.baseAssetAmountShort.abs();
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())) {
+        largerSide = market.amm.baseAssetAmountLong.abs();
+        smallerSide = market.amm.baseAssetAmountShort.abs();
         if (twapSpread.gt(new anchor_1.BN(0))) {
             return [
                 markTwapWithMantissa,
@@ -103,9 +103,9 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
             ];
         }
     }
-    else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
-        largerSide = market.baseAssetAmountShort.abs();
-        smallerSide = market.baseAssetAmountLong.abs();
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())) {
+        largerSide = market.amm.baseAssetAmountShort.abs();
+        smallerSide = market.amm.baseAssetAmountLong.abs();
         if (twapSpread.lt(new anchor_1.BN(0))) {
             return [
                 markTwapWithMantissa,
@@ -184,10 +184,10 @@ exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
  */
 async function calculateLongShortFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
     const [_1, _2, _, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-    if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort)) {
         return [cappedAltEst, interpEst];
     }
-    else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort)) {
         return [interpEst, cappedAltEst];
     }
     else {
@@ -204,10 +204,10 @@ exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
  */
 async function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
     const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = await calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
-    if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+    if (market.amm.baseAssetAmountLong.gt(market.amm.baseAssetAmountShort.abs())) {
         return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
     }
-    else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+    else if (market.amm.baseAssetAmountLong.lt(market.amm.baseAssetAmountShort.abs())) {
         return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
     }
     else {

package/lib/math/margin.js

@@ -4,6 +4,7 @@ exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithO
 const utils_1 = require("./utils");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
+const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
 imfFactor, liabilityWeight, precision) {
@@ -58,9 +59,13 @@ function calculateOraclePriceForPerpMargin(perpPosition, market, oraclePriceData
 }
 exports.calculateOraclePriceForPerpMargin = calculateOraclePriceForPerpMargin;
 function calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData) {
+    let price = oraclePriceData.price;
+    if ((0, types_1.isVariant)(market.status, 'settlement')) {
+        price = market.expiryPrice;
+    }
     return perpPosition.baseAssetAmount
         .abs()
-        .mul(oraclePriceData.price)
+        .mul(price)
         .div(numericConstants_1.AMM_RESERVE_PRECISION);
 }
 exports.calculateBaseAssetValueWithOracle = calculateBaseAssetValueWithOracle;

package/lib/math/market.js

@@ -76,30 +76,30 @@ function calculateUnrealizedAssetWeight(market, quoteSpotMarket, unrealizedPnl,
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = new anchor_1.BN(market.unrealizedInitialAssetWeight);
-            if (market.unrealizedMaxImbalance.gt(numericConstants_1.ZERO)) {
+            assetWeight = new anchor_1.BN(market.unrealizedPnlInitialAssetWeight);
+            if (market.unrealizedPnlMaxImbalance.gt(numericConstants_1.ZERO)) {
                 const netUnsettledPnl = calculateNetUserPnlImbalance(market, quoteSpotMarket, oraclePriceData);
-                if (netUnsettledPnl.gt(market.unrealizedMaxImbalance)) {
+                if (netUnsettledPnl.gt(market.unrealizedPnlMaxImbalance)) {
                     assetWeight = assetWeight
-                        .mul(market.unrealizedMaxImbalance)
+                        .mul(market.unrealizedPnlMaxImbalance)
                         .div(netUnsettledPnl);
                 }
             }
-            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, market.unrealizedImfFactor, assetWeight);
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, market.unrealizedPnlImfFactor, assetWeight);
             break;
         case 'Maintenance':
-            assetWeight = new anchor_1.BN(market.unrealizedMaintenanceAssetWeight);
+            assetWeight = new anchor_1.BN(market.unrealizedPnlMaintenanceAssetWeight);
             break;
     }
     return assetWeight;
 }
 exports.calculateUnrealizedAssetWeight = calculateUnrealizedAssetWeight;
 function calculateMarketAvailablePNL(perpMarket, spotMarket) {
-    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.balance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
 }
 exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
 function calculateNetUserPnl(perpMarket, oraclePriceData) {
-    const netUserPositionValue = perpMarket.amm.netBaseAssetAmount
+    const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
         .mul(oraclePriceData.price)
         .div(numericConstants_1.BASE_PRECISION)
         .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
@@ -112,7 +112,7 @@ function calculateNetUserPnl(perpMarket, oraclePriceData) {
 exports.calculateNetUserPnl = calculateNetUserPnl;
 function calculateNetUserPnlImbalance(perpMarket, spotMarket, oraclePriceData) {
     const netUserPnl = calculateNetUserPnl(perpMarket, oraclePriceData);
-    const pnlPool = (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.balance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const pnlPool = (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
     const imbalance = netUserPnl.sub(pnlPool);
     return imbalance;
 }

package/lib/math/orders.d.ts

@@ -7,8 +7,12 @@ export declare function isOrderRiskIncreasing(user: ClearingHouseUser, order: Or
 export declare function isOrderRiskIncreasingInSameDirection(user: ClearingHouseUser, order: Order): boolean;
 export declare function isOrderReduceOnly(user: ClearingHouseUser, order: Order): boolean;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
-export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number, perpMarket?: PerpMarketAccount): BN;
-export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): boolean;
+export declare function getLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function getOptionalLimitPrice(order: Order, oraclePriceData: OraclePriceData, slot: number): BN | undefined;
+export declare function hasLimitPrice(order: Order, slot: number): boolean;
+export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, ts: number): boolean;
 export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
 export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, market: PerpMarketAccount, limitPrice: BN, oraclePriceData: OraclePriceData): BN;
-export declare function isOrderExpired(order: Order, slot: number): boolean;
+export declare function isOrderExpired(order: Order, ts: number): boolean;
+export declare function isMarketOrder(order: Order): boolean;
+export declare function isLimitOrder(order: Order): boolean;

package/lib/math/orders.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
+exports.isLimitOrder = exports.isMarketOrder = exports.isOrderExpired = exports.calculateBaseAssetAmountToFillUpToLimitPrice = exports.calculateBaseAssetAmountForAmmToFulfill = exports.isFillableByVAMM = exports.hasLimitPrice = exports.getOptionalLimitPrice = exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
 const types_1 = require("../types");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
 const auction_1 = require("./auction");
-const market_1 = require("./market");
 const amm_1 = require("./amm");
 function isOrderRiskIncreasing(user, order) {
     if ((0, types_1.isVariant)(order.status, 'init')) {
@@ -80,10 +79,10 @@ function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
     return baseAssetAmount.sub(remainder);
 }
 exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, oraclePriceData, slot, perpMarket) {
+function getLimitPrice(order, oraclePriceData, slot) {
     let limitPrice;
-    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    if (order.oraclePriceOffset !== 0) {
+        limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
     }
     else if ((0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket'])) {
         if (!(0, auction_1.isAuctionComplete)(order, slot)) {
@@ -93,27 +92,13 @@ function getLimitPrice(order, oraclePriceData, slot, perpMarket) {
             limitPrice = order.price;
         }
         else {
-            if (perpMarket) {
-                if ((0, types_1.isVariant)(order.direction, 'long')) {
-                    const askPrice = (0, market_1.calculateAskPrice)(perpMarket, oraclePriceData);
-                    const delta = askPrice.div(new anchor_1.BN(perpMarket.amm.maxSlippageRatio));
-                    limitPrice = askPrice.add(delta);
-                }
-                else {
-                    const bidPrice = (0, market_1.calculateBidPrice)(perpMarket, oraclePriceData);
-                    const delta = bidPrice.div(new anchor_1.BN(perpMarket.amm.maxSlippageRatio));
-                    limitPrice = bidPrice.sub(delta);
-                }
+            // check oracle validity?
+            const oraclePrice1Pct = oraclePriceData.price.div(new anchor_1.BN(100));
+            if ((0, types_1.isVariant)(order.direction, 'long')) {
+                limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
             }
             else {
-                // check oracle validity?
-                const oraclePrice1Pct = oraclePriceData.price.div(new anchor_1.BN(100));
-                if ((0, types_1.isVariant)(order.direction, 'long')) {
-                    limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
-                }
-                else {
-                    limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
-                }
+                limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
             }
         }
     }
@@ -123,10 +108,25 @@ function getLimitPrice(order, oraclePriceData, slot, perpMarket) {
     return limitPrice;
 }
 exports.getLimitPrice = getLimitPrice;
-function isFillableByVAMM(order, market, oraclePriceData, slot) {
+function getOptionalLimitPrice(order, oraclePriceData, slot) {
+    if (hasLimitPrice(order, slot)) {
+        return getLimitPrice(order, oraclePriceData, slot);
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getOptionalLimitPrice = getOptionalLimitPrice;
+function hasLimitPrice(order, slot) {
+    return (order.price.gt(numericConstants_1.ZERO) ||
+        order.oraclePriceOffset != 0 ||
+        !(0, auction_1.isAuctionComplete)(order, slot));
+}
+exports.hasLimitPrice = hasLimitPrice;
+function isFillableByVAMM(order, market, oraclePriceData, slot, ts) {
     return (((0, auction_1.isAuctionComplete)(order, slot) &&
         !calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot).eq(numericConstants_1.ZERO)) ||
-        isOrderExpired(order, slot));
+        isOrderExpired(order, ts));
 }
 exports.isFillableByVAMM = isFillableByVAMM;
 function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData, slot) {
@@ -134,7 +134,7 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData,
         order.triggered === false) {
         return numericConstants_1.ZERO;
     }
-    const limitPrice = getLimitPrice(order, oraclePriceData, slot, market);
+    const limitPrice = getLimitPrice(order, oraclePriceData, slot);
     const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData);
     const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(market.amm, order.direction);
     return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
@@ -142,7 +142,7 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, oraclePriceData,
 exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
 function calculateBaseAssetAmountToFillUpToLimitPrice(order, market, limitPrice, oraclePriceData) {
     const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
-    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, market.amm.orderStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {
@@ -157,12 +157,20 @@ 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')));
 }
-function isOrderExpired(order, slot) {
+function isOrderExpired(order, ts) {
     if ((0, types_1.isOneOfVariant)(order.orderType, ['triggerMarket', 'triggerLimit']) ||
         !(0, types_1.isVariant)(order.status, 'open') ||
-        order.timeInForce === 0) {
+        order.maxTs.eq(numericConstants_1.ZERO)) {
         return false;
     }
-    return new anchor_1.BN(slot).sub(order.slot).gt(new anchor_1.BN(order.timeInForce));
+    return new anchor_1.BN(ts).gt(order.maxTs);
 }
 exports.isOrderExpired = isOrderExpired;
+function isMarketOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['market', 'triggerMarket']);
+}
+exports.isMarketOrder = isMarketOrder;
+function isLimitOrder(order) {
+    return (0, types_1.isOneOfVariant)(order.orderType, ['limit', 'triggerLimit']);
+}
+exports.isLimitOrder = isLimitOrder;

package/lib/math/repeg.js

@@ -15,7 +15,7 @@ function calculateAdjustKCost(amm, numerator, denomenator) {
     // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
     const x = amm.baseAssetReserve;
     const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
+    const d = amm.baseAssetAmountWithAmm;
     const Q = amm.pegMultiplier;
     const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
     const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
@@ -101,7 +101,7 @@ function calculateBudgetedK(amm, cost) {
     // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
     const x = amm.baseAssetReserve;
     const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
+    const d = amm.baseAssetAmountWithAmm;
     const Q = amm.pegMultiplier;
     const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
     return [numerator, denominator];
@@ -120,7 +120,7 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     const k = amm.sqrtK.mul(amm.sqrtK);
     const x = amm.baseAssetReserve;
     const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
+    const d = amm.baseAssetAmountWithAmm;
     const Q = amm.pegMultiplier;
     const C = cost.mul(new anchor_1.BN(-1));
     const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));

package/lib/math/spotBalance.js

@@ -177,12 +177,12 @@ function calculateWithdrawLimit(spotMarket, now) {
     const borrowTokenTwapLive = spotMarket.borrowTokenTwap
         .mul(sinceStart)
         .add(marketBorrowTokenAmount.mul(sinceLast))
-        .div(sinceLast.add(sinceLast));
+        .div(sinceLast.add(sinceStart));
     const depositTokenTwapLive = spotMarket.depositTokenTwap
         .mul(sinceStart)
         .add(marketDepositTokenAmount.mul(sinceLast))
-        .div(sinceLast.add(sinceLast));
-    const maxBorrowTokens = anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new anchor_1.BN(10)))); // between ~15-90% utilization with friction on twap
+        .div(sinceLast.add(sinceStart));
+    const maxBorrowTokens = anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new anchor_1.BN(5)))); // between ~15-80% utilization with friction on twap
     const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), spotMarket.withdrawGuardThreshold), depositTokenTwapLive));
     return {
         borrowLimit: maxBorrowTokens.sub(marketBorrowTokenAmount),

package/lib/math/spotPosition.js

@@ -4,11 +4,11 @@ exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const spotBalance_1 = require("./spotBalance");
 function isSpotPositionAvailable(position) {
-    return position.balance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+    return position.scaledBalance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
 function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
-    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
     const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
     if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {

package/lib/serum/serumFulfillmentConfigMap.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from '@solana/web3.js';
+import { SerumV3FulfillmentConfigAccount } from '../types';
+import { ClearingHouse } from '../clearingHouse';
+export declare class SerumFulfillmentConfigMap {
+    clearingHouse: ClearingHouse;
+    map: Map<number, SerumV3FulfillmentConfigAccount>;
+    constructor(clearingHouse: ClearingHouse);
+    add(marketIndex: number, serumMarketAddress: PublicKey): Promise<void>;
+    get(marketIndex: number): SerumV3FulfillmentConfigAccount;
+}

package/lib/serum/serumFulfillmentConfigMap.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumFulfillmentConfigMap = void 0;
+class SerumFulfillmentConfigMap {
+    constructor(clearingHouse) {
+        this.map = new Map();
+        this.clearingHouse = clearingHouse;
+    }
+    async add(marketIndex, serumMarketAddress) {
+        const account = await this.clearingHouse.getSerumV3FulfillmentConfig(serumMarketAddress);
+        this.map.set(marketIndex, account);
+    }
+    get(marketIndex) {
+        return this.map.get(marketIndex);
+    }
+}
+exports.SerumFulfillmentConfigMap = SerumFulfillmentConfigMap;

package/lib/serum/serumSubscriber.d.ts

@@ -1,7 +1,9 @@
+/// <reference types="bn.js" />
 import { Connection, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
 import { Market, Orderbook } from '@project-serum/serum';
 import { SerumMarketSubscriberConfig } from './types';
+import { BN } from '@project-serum/anchor';
 export declare class SerumSubscriber {
     connection: Connection;
     programId: PublicKey;
@@ -19,5 +21,7 @@ export declare class SerumSubscriber {
     lastBidsSlot: number;
     constructor(config: SerumMarketSubscriberConfig);
     subscribe(): Promise<void>;
+    getBestBid(): BN | undefined;
+    getBestAsk(): BN | undefined;
     unsubscribe(): Promise<void>;
 }

package/lib/serum/serumSubscriber.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SerumSubscriber = void 0;
 const serum_1 = require("@project-serum/serum");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
 class SerumSubscriber {
     constructor(config) {
         this.connection = config.connection;
@@ -19,7 +21,6 @@ class SerumSubscriber {
         this.asksCallbackId = this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
             this.lastAsksSlot = slot;
             this.asks = serum_1.Orderbook.decode(this.market, buffer);
-            console.log(this.asks.getL2(3));
         });
         this.bidsAddress = this.market.bidsAddress;
         this.bids = await this.market.loadBids(this.connection);
@@ -29,6 +30,20 @@ class SerumSubscriber {
         });
         this.subscribed = true;
     }
+    getBestBid() {
+        const bestBid = this.bids.getL2(1)[0];
+        if (!bestBid) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestBid[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
+    getBestAsk() {
+        const bestAsk = this.asks.getL2(1)[0];
+        if (!bestAsk) {
+            return undefined;
+        }
+        return new anchor_1.BN(bestAsk[0] * numericConstants_1.PRICE_PRECISION.toNumber());
+    }
     async unsubscribe() {
         if (!this.subscribed) {
             return;