@drift-labs/sdk 0.2.0-master.25 → 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';
@@ -31,6 +31,7 @@ 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';
@@ -49,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);
@@ -54,6 +54,7 @@ __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);
@@ -72,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];
@@ -66,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

@@ -226,7 +226,7 @@ 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);

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;

package/lib/math/position.js

@@ -52,36 +52,36 @@ exports.calculateBaseAssetValue = calculateBaseAssetValue;
  * 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
  */
-function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return marketPosition.quoteAssetAmount;
+function calculatePositionPNL(market, perpPosition, withFunding = false, oraclePriceData) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return perpPosition.quoteAssetAmount;
     }
-    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, marketPosition, oraclePriceData);
-    const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
         ? new __1.BN(-1)
         : new __1.BN(1);
     let pnl = baseAssetValue
         .mul(baseAssetValueSign)
-        .add(marketPosition.quoteAssetAmount);
+        .add(perpPosition.quoteAssetAmount);
     if (withFunding) {
-        const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
         pnl = pnl.add(fundingRatePnL);
     }
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
-function calculateUnsettledPnl(market, marketPosition, oraclePriceData) {
-    const unrealizedPnl = calculatePositionPNL(market, marketPosition, true, oraclePriceData);
+function calculateUnsettledPnl(market, perpPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
     let unsettledPnl = unrealizedPnl;
     if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
-        const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
-        const maxPositivePnl = __1.BN.max(marketPosition.quoteAssetAmount
-            .sub(marketPosition.quoteEntryAmount)
+        const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount
+            .sub(perpPosition.quoteEntryAmount)
             .add(fundingPnL), numericConstants_1.ZERO);
         unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
     }
@@ -91,23 +91,23 @@ exports.calculateUnsettledPnl = calculateUnsettledPnl;
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-function calculatePositionFundingPNL(market, marketPosition) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+function calculatePositionFundingPNL(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     let ammCumulativeFundingRate;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
         ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
     }
     else {
         ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
     }
     const perPositionFundingRate = ammCumulativeFundingRate
-        .sub(marketPosition.lastCumulativeFundingRate)
-        .mul(marketPosition.baseAssetAmount)
+        .sub(perpPosition.lastCumulativeFundingRate)
+        .mul(perpPosition.baseAssetAmount)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
         .mul(new __1.BN(-1));

package/lib/math/spotBalance.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
+import { BN } from '@project-serum/anchor';
+export declare function getBalance(tokenAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getTokenAmount(balanceAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateUtilization(bank: SpotMarketAccount): BN;
+export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
+export declare function calculateDepositRate(bank: SpotMarketAccount): BN;
+export declare function calculateBorrowRate(bank: SpotMarketAccount): BN;
+export declare function calculateInterestAccumulated(bank: SpotMarketAccount, now: BN): {
+    borrowInterest: BN;
+    depositInterest: BN;
+};
+export declare function calculateWithdrawLimit(spotMarket: SpotMarketAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: BN;
+};