@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/lib/index.d.ts

@@ -6,7 +6,7 @@ export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
 export * from './types';
-export * from './constants/markets';
+export * from './constants/perpMarkets';
 export * from './accounts/fetch';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
@@ -29,7 +29,9 @@ export * from './factory/oracleClient';
 export * from './factory/bigNum';
 export * from './events/types';
 export * from './events/eventSubscriber';
+export * from './events/fetchLogs';
 export * from './math/auction';
+export * from './math/spotMarket';
 export * from './math/conversion';
 export * from './math/funding';
 export * from './math/market';
@@ -48,10 +50,11 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './serum/serumSubscriber';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
-export * from './math/bankBalance';
-export * from './constants/banks';
+export * from './math/spotBalance';
+export * from './constants/spotMarkets';
 export * from './clearingHouseConfig';
 export { BN, PublicKey, pyth };

package/lib/index.js

@@ -29,7 +29,7 @@ __exportStar(require("./oracles/types"), exports);
 __exportStar(require("./oracles/pythClient"), exports);
 __exportStar(require("./oracles/switchboardClient"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./constants/markets"), exports);
+__exportStar(require("./constants/perpMarkets"), exports);
 __exportStar(require("./accounts/fetch"), exports);
 __exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), exports);
 __exportStar(require("./accounts/bulkAccountLoader"), exports);
@@ -52,7 +52,9 @@ __exportStar(require("./factory/oracleClient"), exports);
 __exportStar(require("./factory/bigNum"), exports);
 __exportStar(require("./events/types"), exports);
 __exportStar(require("./events/eventSubscriber"), exports);
+__exportStar(require("./events/fetchLogs"), exports);
 __exportStar(require("./math/auction"), exports);
+__exportStar(require("./math/spotMarket"), exports);
 __exportStar(require("./math/conversion"), exports);
 __exportStar(require("./math/funding"), exports);
 __exportStar(require("./math/market"), exports);
@@ -71,9 +73,10 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./math/utils"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./constants/numericConstants"), exports);
+__exportStar(require("./serum/serumSubscriber"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);
-__exportStar(require("./math/bankBalance"), exports);
-__exportStar(require("./constants/banks"), exports);
+__exportStar(require("./math/spotBalance"), exports);
+__exportStar(require("./constants/spotMarkets"), exports);
 __exportStar(require("./clearingHouseConfig"), exports);

package/lib/math/amm.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { AMM, PositionDirection, SwapDirection, MarketAccount } from '../types';
+import { AMM, PositionDirection, SwapDirection, PerpMarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 export declare function calculatePegFromTargetPrice(targetPrice: BN, baseAssetReserve: BN, quoteAssetReserve: BN): BN;
 export declare function calculateOptimalPegAndBudget(amm: AMM, oraclePriceData: OraclePriceData): [BN, BN, BN, boolean];
@@ -33,9 +33,11 @@ export declare type AssetType = 'quote' | 'base';
  * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
  */
 export declare function calculateAmmReservesAfterSwap(amm: Pick<AMM, 'pegMultiplier' | 'quoteAssetReserve' | 'sqrtK' | 'baseAssetReserve'>, inputAssetType: AssetType, swapAmount: BN, swapDirection: SwapDirection): [BN, BN];
+export declare function calculateMarketOpenBidAsk(baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): [BN, BN];
+export declare function calculateInventoryScale(netBaseAssetAmount: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): number;
 export declare function calculateEffectiveLeverage(baseSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, markPrice: BN, totalFeeMinusDistributions: BN): number;
 export declare function calculateMaxSpread(marginRatioInitial: number): number;
-export declare function calculateSpreadBN(baseSpread: number, lastOracleMarkSpreadPct: BN, lastOracleConfPct: BN, maxSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, markPrice: BN, totalFeeMinusDistributions: BN): [number, number];
+export declare function calculateSpreadBN(baseSpread: number, lastOracleMarkSpreadPct: BN, lastOracleConfPct: BN, maxSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, markPrice: BN, totalFeeMinusDistributions: BN, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): [number, number];
 export declare function calculateSpread(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): number;
 export declare function calculateSpreadReserves(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): {
     baseAssetReserve: BN;
@@ -64,7 +66,7 @@ export declare function getSwapDirection(inputAssetType: AssetType, positionDire
  * @param market
  * @returns cost : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateTerminalPrice(market: MarketAccount): BN;
+export declare function calculateTerminalPrice(market: PerpMarketAccount): BN;
 export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN, direction: PositionDirection, oraclePriceData?: OraclePriceData): [BN, PositionDirection];
 export declare function calculateQuoteAssetAmountSwapped(quoteAssetReserves: BN, pegMultiplier: BN, swapDirection: SwapDirection): BN;
 export declare function calculateMaxBaseAssetAmountFillable(amm: AMM, orderDirection: PositionDirection): BN;

package/lib/math/amm.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
+exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateInventoryScale = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -165,6 +165,36 @@ function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDire
     return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
+function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+    // open orders
+    let openAsks;
+    if (maxBaseAssetReserve > baseAssetReserve) {
+        openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new anchor_1.BN(-1));
+    }
+    else {
+        openAsks = numericConstants_1.ZERO;
+    }
+    let openBids;
+    if (minBaseAssetReserve < baseAssetReserve) {
+        openBids = baseAssetReserve.sub(minBaseAssetReserve);
+    }
+    else {
+        openBids = numericConstants_1.ZERO;
+    }
+    return [openBids, openAsks];
+}
+exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
+function calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+    // inventory skew
+    const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
+    const totalLiquidity = anchor_1.BN.max(openBids.abs().add(openAsks.abs()), new anchor_1.BN(1));
+    const inventoryScale = anchor_1.BN.min(netBaseAssetAmount.abs(), totalLiquidity)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(5)))
+        .div(totalLiquidity)
+        .toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
+    return inventoryScale;
+}
+exports.calculateInventoryScale = calculateInventoryScale;
 function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
     // inventory skew
     const netBaseAssetValue = quoteAssetReserve
@@ -187,7 +217,7 @@ function calculateMaxSpread(marginRatioInitial) {
     return maxTargetSpread;
 }
 exports.calculateMaxSpread = calculateMaxSpread;
-function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
     let longSpread = baseSpread / 2;
     let shortSpread = baseSpread / 2;
     if (lastOracleMarkSpreadPct.gt(numericConstants_1.ZERO)) {
@@ -196,8 +226,16 @@ function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPc
     else if (lastOracleMarkSpreadPct.lt(numericConstants_1.ZERO)) {
         longSpread = Math.max(longSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
     }
-    const maxTargetSpread = maxSpread;
+    const maxTargetSpread = Math.max(maxSpread, lastOracleMarkSpreadPct.abs().toNumber());
     const MAX_INVENTORY_SKEW = 5;
+    const inventoryScale = calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
+    const inventorySpreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + inventoryScale);
+    if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+        longSpread *= inventorySpreadScale;
+    }
+    else if (netBaseAssetAmount.lt(numericConstants_1.ZERO)) {
+        shortSpread *= inventorySpreadScale;
+    }
     const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions);
     if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
         const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
@@ -240,7 +278,7 @@ function calculateSpread(amm, direction, oraclePriceData) {
     const confIntervalPct = confInterval
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(markPrice);
-    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions);
+    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
     let spread;
     if ((0, types_1.isVariant)(direction, 'long')) {
         spread = longSpread;

package/lib/math/funding.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { MarketAccount } from '../types';
+import { PerpMarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 /**
  *
@@ -9,7 +9,7 @@ import { OraclePriceData } from '../oracles/types';
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateAllEstimatedFundingRate(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN, BN]>;
+export declare function calculateAllEstimatedFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN, BN]>;
 /**
  *
  * @param market
@@ -18,7 +18,7 @@ export declare function calculateAllEstimatedFundingRate(market: MarketAccount,
  * @param estimationMethod
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateEstimatedFundingRate(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN, estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'): Promise<BN>;
+export declare function calculateEstimatedFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN, estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'): Promise<BN>;
 /**
  *
  * @param market
@@ -26,7 +26,7 @@ export declare function calculateEstimatedFundingRate(market: MarketAccount, ora
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateLongShortFundingRate(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN]>;
+export declare function calculateLongShortFundingRate(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN]>;
 /**
  *
  * @param market
@@ -34,10 +34,10 @@ export declare function calculateLongShortFundingRate(market: MarketAccount, ora
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
-export declare function calculateLongShortFundingRateAndLiveTwaps(market: MarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN]>;
+export declare function calculateLongShortFundingRateAndLiveTwaps(market: PerpMarketAccount, oraclePriceData?: OraclePriceData, periodAdjustment?: BN): Promise<[BN, BN, BN, BN]>;
 /**
  *
  * @param market
  * @returns Estimated fee pool size
  */
-export declare function calculateFundingPool(market: MarketAccount): BN;
+export declare function calculateFundingPool(market: PerpMarketAccount): BN;

package/lib/math/funding.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateFundingPool = exports.calculateLongShortFundingRateAndLiveTwaps = exports.calculateLongShortFundingRate = exports.calculateEstimatedFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
+const types_1 = require("../types");
 const market_1 = require("./market");
 /**
  *
@@ -19,7 +20,7 @@ async function calculateAllEstimatedFundingRate(market, oraclePriceData, periodA
     const secondsInHour = new anchor_1.BN(3600);
     const hoursInDay = new anchor_1.BN(24);
     const ONE = new anchor_1.BN(1);
-    if (!market.initialized) {
+    if ((0, types_1.isVariant)(market.status, 'uninitialized')) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
     }
     const payFreq = new anchor_1.BN(market.amm.fundingPeriod);

package/lib/math/margin.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, UserPosition } from '..';
+import { PerpMarketAccount, PerpPosition } from '..';
 export declare function calculateSizePremiumLiabilityWeight(size: BN, // AMM_RESERVE_PRECISION
 imfFactor: BN, liabilityWeight: BN, precision: BN): BN;
 export declare function calculateSizeDiscountAssetWeight(size: BN, // AMM_RESERVE_PRECISION
 imfFactor: BN, assetWeight: BN): BN;
-export declare function calculateOraclePriceForPerpMargin(marketPosition: UserPosition, market: MarketAccount, oraclePriceData: OraclePriceData): BN;
-export declare function calculateBaseAssetValueWithOracle(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
-export declare function calculateWorstCaseBaseAssetAmount(marketPosition: UserPosition): BN;
+export declare function calculateOraclePriceForPerpMargin(perpPosition: PerpPosition, market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBaseAssetValueWithOracle(market: PerpMarketAccount, perpPosition: PerpPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateWorstCaseBaseAssetAmount(perpPosition: PerpPosition): BN;

package/lib/math/margin.js

@@ -4,16 +4,21 @@ exports.calculateWorstCaseBaseAssetAmount = exports.calculateBaseAssetValueWithO
 const utils_1 = require("./utils");
 const numericConstants_1 = require("../constants/numericConstants");
 const anchor_1 = require("@project-serum/anchor");
+const assert_1 = require("../assert/assert");
 function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
 imfFactor, liabilityWeight, precision) {
     if (imfFactor.eq(numericConstants_1.ZERO)) {
         return liabilityWeight;
     }
     const sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
-    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.BANK_IMF_PRECISION.div(imfFactor))));
+    const denom0 = anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor));
+    (0, assert_1.assert)(denom0.gt(numericConstants_1.ZERO));
+    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(imfFactor))));
+    const denom = new anchor_1.BN(100000).mul(numericConstants_1.SPOT_MARKET_IMF_PRECISION).div(precision);
+    (0, assert_1.assert)(denom.gt(numericConstants_1.ZERO));
     const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(sizeSqrt // 1e5
         .mul(imfFactor)
-        .div(new anchor_1.BN(100000).mul(numericConstants_1.BANK_IMF_PRECISION).div(precision)) // 1e5
+        .div(denom) // 1e5
     );
     const maxLiabilityWeight = anchor_1.BN.max(liabilityWeight, sizePremiumLiabilityWeight);
     return maxLiabilityWeight;
@@ -25,8 +30,10 @@ imfFactor, assetWeight) {
         return assetWeight;
     }
     const sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
-    const imfNumerator = numericConstants_1.BANK_IMF_PRECISION.add(numericConstants_1.BANK_IMF_PRECISION.div(new anchor_1.BN(10)));
-    const sizeDiscountAssetWeight = imfNumerator.mul(numericConstants_1.BANK_WEIGHT_PRECISION).div(numericConstants_1.BANK_IMF_PRECISION.add(sizeSqrt // 1e5
+    const imfNumerator = numericConstants_1.SPOT_MARKET_IMF_PRECISION.add(numericConstants_1.SPOT_MARKET_IMF_PRECISION.div(new anchor_1.BN(10)));
+    const sizeDiscountAssetWeight = imfNumerator
+        .mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION)
+        .div(numericConstants_1.SPOT_MARKET_IMF_PRECISION.add(sizeSqrt // 1e5
         .mul(imfFactor)
         .div(new anchor_1.BN(100000)) // 1e5
     ));
@@ -34,14 +41,14 @@ imfFactor, assetWeight) {
     return minAssetWeight;
 }
 exports.calculateSizeDiscountAssetWeight = calculateSizeDiscountAssetWeight;
-function calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceData) {
+function calculateOraclePriceForPerpMargin(perpPosition, market, oraclePriceData) {
     const oraclePriceOffset = anchor_1.BN.min(new anchor_1.BN(market.amm.maxSpread)
         .mul(oraclePriceData.price)
         .div(numericConstants_1.BID_ASK_SPREAD_PRECISION), oraclePriceData.confidence.add(new anchor_1.BN(market.amm.baseSpread)
         .mul(oraclePriceData.price)
         .div(numericConstants_1.BID_ASK_SPREAD_PRECISION)));
     let marginPrice;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
         marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
     }
     else {
@@ -50,16 +57,16 @@ function calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceDa
     return marginPrice;
 }
 exports.calculateOraclePriceForPerpMargin = calculateOraclePriceForPerpMargin;
-function calculateBaseAssetValueWithOracle(market, marketPosition, oraclePriceData) {
-    return marketPosition.baseAssetAmount
+function calculateBaseAssetValueWithOracle(market, perpPosition, oraclePriceData) {
+    return perpPosition.baseAssetAmount
         .abs()
         .mul(oraclePriceData.price)
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
 }
 exports.calculateBaseAssetValueWithOracle = calculateBaseAssetValueWithOracle;
-function calculateWorstCaseBaseAssetAmount(marketPosition) {
-    const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
-    const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);
+function calculateWorstCaseBaseAssetAmount(perpPosition) {
+    const allBids = perpPosition.baseAssetAmount.add(perpPosition.openBids);
+    const allAsks = perpPosition.baseAssetAmount.add(perpPosition.openAsks);
     if (allBids.abs().gt(allAsks.abs())) {
         return allBids;
     }

package/lib/math/market.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection, MarginCategory, BankAccount } from '../types';
+import { PerpMarketAccount, PositionDirection, MarginCategory, SpotMarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 /**
  * Calculates market mark price
@@ -8,24 +8,25 @@ import { OraclePriceData } from '../oracles/types';
  * @param market
  * @return markPrice : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateMarkPrice(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarkPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 /**
  * Calculates market bid price
  *
  * @param market
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateBidPrice(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBidPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 /**
  * Calculates market ask price
  *
  * @param market
  * @return bidPrice : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateAskPrice(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
-export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: MarketAccount): MarketAccount;
-export declare function calculateMarkOracleSpread(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateAskPrice(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: PerpMarketAccount): PerpMarketAccount;
+export declare function calculateMarkOracleSpread(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): BN;
-export declare function calculateMarketMarginRatio(market: MarketAccount, size: BN, marginCategory: MarginCategory): number;
-export declare function calculateUnrealizedAssetWeight(market: MarketAccount, unrealizedPnl: BN, marginCategory: MarginCategory): BN;
-export declare function calculateMarketAvailablePNL(market: MarketAccount, bank: BankAccount): BN;
+export declare function calculateMarketMarginRatio(market: PerpMarketAccount, size: BN, marginCategory: MarginCategory): number;
+export declare function calculateUnrealizedAssetWeight(market: PerpMarketAccount, quoteSpotMarket: SpotMarketAccount, unrealizedPnl: BN, marginCategory: MarginCategory, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarketAvailablePNL(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;
+export declare function calculateNetUserImbalance(market: PerpMarketAccount, bank: SpotMarketAccount, oraclePriceData: OraclePriceData): BN;

package/lib/math/market.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+exports.calculateNetUserImbalance = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
 const margin_1 = require("./margin");
 const numericConstants_1 = require("../constants/numericConstants");
-const bankBalance_1 = require("./bankBalance");
+const spotBalance_1 = require("./spotBalance");
 /**
  * Calculates market mark price
  *
@@ -72,11 +72,20 @@ function calculateMarketMarginRatio(market, size, marginCategory) {
     return marginRatio;
 }
 exports.calculateMarketMarginRatio = calculateMarketMarginRatio;
-function calculateUnrealizedAssetWeight(market, unrealizedPnl, marginCategory) {
+function calculateUnrealizedAssetWeight(market, quoteSpotMarket, unrealizedPnl, marginCategory, oraclePriceData) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, market.unrealizedImfFactor, new anchor_1.BN(market.unrealizedInitialAssetWeight));
+            assetWeight = new anchor_1.BN(market.unrealizedInitialAssetWeight);
+            if (market.unrealizedMaxImbalance.gt(numericConstants_1.ZERO)) {
+                const netUnsettledPnl = calculateNetUserImbalance(market, quoteSpotMarket, oraclePriceData);
+                if (netUnsettledPnl.gt(market.unrealizedMaxImbalance)) {
+                    assetWeight = assetWeight
+                        .mul(market.unrealizedMaxImbalance)
+                        .div(netUnsettledPnl);
+                }
+            }
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unrealizedPnl, market.unrealizedImfFactor, assetWeight);
             break;
         case 'Maintenance':
             assetWeight = new anchor_1.BN(market.unrealizedMaintenanceAssetWeight);
@@ -85,7 +94,21 @@ function calculateUnrealizedAssetWeight(market, unrealizedPnl, marginCategory) {
     return assetWeight;
 }
 exports.calculateUnrealizedAssetWeight = calculateUnrealizedAssetWeight;
-function calculateMarketAvailablePNL(market, bank) {
-    return (0, bankBalance_1.getTokenAmount)(market.pnlPool.balance, bank, types_1.BankBalanceType.DEPOSIT);
+function calculateMarketAvailablePNL(perpMarket, spotMarket) {
+    return (0, spotBalance_1.getTokenAmount)(perpMarket.pnlPool.balance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
 }
 exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
+function calculateNetUserImbalance(market, bank, oraclePriceData) {
+    const netUserPositionValue = market.amm.netBaseAssetAmount
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BASE_PRECISION)
+        .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+    const netUserCostBasis = market.amm.quoteAssetAmountLong
+        .add(market.amm.quoteAssetAmountShort)
+        .sub(market.amm.cumulativeSocialLoss);
+    const userEntitledPnl = netUserPositionValue.add(netUserCostBasis);
+    const pnlPool = (0, spotBalance_1.getTokenAmount)(market.pnlPool.balance, bank, types_1.SpotBalanceType.DEPOSIT);
+    const imbalance = userEntitledPnl.sub(pnlPool);
+    return imbalance;
+}
+exports.calculateNetUserImbalance = calculateNetUserImbalance;

package/lib/math/oracles.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="bn.js" />
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
-import { BN } from '../index';
+import { BN, PerpMarketAccount } from '../index';
+export declare function oraclePriceBands(market: PerpMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];
 export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
 export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, now: BN): boolean;

package/lib/math/oracles.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleTooDivergent = exports.isOracleValid = void 0;
+exports.isOracleTooDivergent = exports.isOracleValid = exports.oraclePriceBands = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const index_1 = require("../index");
+const assert_1 = require("../assert/assert");
+function oraclePriceBands(market, oraclePriceData) {
+    const maxPercentDiff = market.marginRatioInitial - market.marginRatioMaintenance;
+    const offset = oraclePriceData.price
+        .mul(new index_1.BN(maxPercentDiff))
+        .div(numericConstants_1.MARGIN_PRECISION);
+    (0, assert_1.assert)(offset.gt(numericConstants_1.ZERO));
+    return [oraclePriceData.price.sub(offset), oraclePriceData.price.add(offset)];
+}
+exports.oraclePriceBands = oraclePriceBands;
 function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
     const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price

package/lib/math/orders.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="bn.js" />
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { MarketAccount, Order } from '../types';
+import { PerpMarketAccount, Order } from '../types';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/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;
 export declare function standardizeBaseAssetAmount(baseAssetAmount: BN, stepSize: BN): BN;
-export declare function getLimitPrice(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
-export declare function isFillableByVAMM(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number, maxAuctionDuration: number): boolean;
-export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: MarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
-export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, market: MarketAccount, limitPrice: BN, oraclePriceData: OraclePriceData): BN;
+export declare function getLimitPrice(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number): BN;
+export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, oraclePriceData: OraclePriceData, slot: number, maxAuctionDuration: 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, maxAuctionDuration: number): boolean;

package/lib/math/position.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { BN } from '../';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -10,38 +10,38 @@ import { MarketAccount, PositionDirection, UserPosition } from '../types';
  * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-export declare function calculateBaseAssetValue(market: MarketAccount, userPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBaseAssetValue(market: PerpMarketAccount, userPosition: PerpPosition, oraclePriceData: OraclePriceData): BN;
 /**
  * calculatePositionPNL
  * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
  * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
-export declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
-export declare function calculateUnsettledPnl(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculatePositionPNL(market: PerpMarketAccount, perpPosition: PerpPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculateUnsettledPnl(market: PerpMarketAccount, perpPosition: PerpPosition, oraclePriceData: OraclePriceData): BN;
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-export declare function calculatePositionFundingPNL(market: MarketAccount, marketPosition: UserPosition): BN;
-export declare function positionIsAvailable(position: UserPosition): boolean;
+export declare function calculatePositionFundingPNL(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
+export declare function positionIsAvailable(position: PerpPosition): boolean;
 /**
  *
  * @param userPosition
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
-export declare function calculateEntryPrice(userPosition: UserPosition): BN;
+export declare function calculateEntryPrice(userPosition: PerpPosition): BN;
 /**
  *
  * @param userPosition
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
-export declare function calculateCostBasis(userPosition: UserPosition): BN;
-export declare function findDirectionToClose(userPosition: UserPosition): PositionDirection;
-export declare function positionCurrentDirection(userPosition: UserPosition): PositionDirection;
-export declare function isEmptyPosition(userPosition: UserPosition): boolean;
+export declare function calculateCostBasis(userPosition: PerpPosition): BN;
+export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;
+export declare function positionCurrentDirection(userPosition: PerpPosition): PositionDirection;
+export declare function isEmptyPosition(userPosition: PerpPosition): boolean;