@drift-labs/sdk 0.2.0-master.30 → 0.2.0-master.31

package/lib/math/amm.d.ts

@@ -35,9 +35,9 @@ export declare type AssetType = 'quote' | 'base';
 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 calculateEffectiveLeverage(baseSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, reservePrice: 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, baseAssetReserve: BN, minBaseAssetReserve: BN, maxBaseAssetReserve: BN): [number, number];
+export declare function calculateSpreadBN(baseSpread: number, lastOracleReservePriceSpreadPct: BN, lastOracleConfPct: BN, maxSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, reservePrice: 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;

package/lib/math/amm.js

@@ -16,7 +16,7 @@ function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetRe
 }
 exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
 function calculateOptimalPegAndBudget(amm, oraclePriceData) {
-    const markPriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    const reservePriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
     const targetPrice = oraclePriceData.price;
     const newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
     const prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
@@ -29,14 +29,14 @@ function calculateOptimalPegAndBudget(amm, oraclePriceData) {
         let newTargetPrice;
         let newOptimalPeg;
         let newBudget;
-        const targetPriceGap = markPriceBefore.sub(targetPrice);
+        const targetPriceGap = reservePriceBefore.sub(targetPrice);
         if (targetPriceGap.abs().gt(maxPriceSpread)) {
             const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
             if (targetPriceGap.lt(new anchor_1.BN(0))) {
-                newTargetPrice = markPriceBefore.add(markAdj);
+                newTargetPrice = reservePriceBefore.add(markAdj);
             }
             else {
-                newTargetPrice = markPriceBefore.sub(markAdj);
+                newTargetPrice = reservePriceBefore.sub(markAdj);
             }
             newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
             newBudget = (0, repeg_1.calculateRepegCost)(amm, newOptimalPeg);
@@ -185,24 +185,22 @@ function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBas
 }
 exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
 function calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+    const maxScale = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
     // inventory skew
     const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
     const minSideLiquidity = anchor_1.BN.max(new anchor_1.BN(1), anchor_1.BN.min(openBids.abs(), openAsks.abs()));
-    const inventoryScale = anchor_1.BN.min(netBaseAssetAmount.abs(), minSideLiquidity)
-        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10)))
-        .div(minSideLiquidity)
-        .toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
+    const inventoryScale = anchor_1.BN.min(maxScale, netBaseAssetAmount.mul(maxScale).div(minSideLiquidity).abs()).toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
     return inventoryScale;
 }
 exports.calculateInventoryScale = calculateInventoryScale;
-function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions) {
     // inventory skew
     const netBaseAssetValue = quoteAssetReserve
         .sub(terminalQuoteAssetReserve)
         .mul(pegMultiplier)
         .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
     const localBaseAssetValue = netBaseAssetAmount
-        .mul(markPrice)
+        .mul(reservePrice)
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
     const effectiveLeverage = localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
         (Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
@@ -217,28 +215,30 @@ function calculateMaxSpread(marginRatioInitial) {
     return maxTargetSpread;
 }
 exports.calculateMaxSpread = calculateMaxSpread;
-function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
+function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
     let longSpread = baseSpread / 2;
     let shortSpread = baseSpread / 2;
-    if (lastOracleMarkSpreadPct.gt(numericConstants_1.ZERO)) {
-        shortSpread = Math.max(shortSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
+    if (lastOracleReservePriceSpreadPct.gt(numericConstants_1.ZERO)) {
+        shortSpread = Math.max(shortSpread, lastOracleReservePriceSpreadPct.abs().toNumber() +
+            lastOracleConfPct.toNumber());
     }
-    else if (lastOracleMarkSpreadPct.lt(numericConstants_1.ZERO)) {
-        longSpread = Math.max(longSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
+    else if (lastOracleReservePriceSpreadPct.lt(numericConstants_1.ZERO)) {
+        longSpread = Math.max(longSpread, lastOracleReservePriceSpreadPct.abs().toNumber() +
+            lastOracleConfPct.toNumber());
     }
-    const maxTargetSpread = Math.max(maxSpread, lastOracleMarkSpreadPct.abs().toNumber());
-    const MAX_INVENTORY_SKEW = 5;
+    const maxTargetSpread = Math.max(maxSpread, lastOracleReservePriceSpreadPct.abs().toNumber());
+    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = 10;
     const inventoryScale = calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
-    const inventorySpreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + inventoryScale);
+    const inventorySpreadScale = Math.min(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, 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);
+    const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions);
     if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
-        const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        const spreadScale = Math.min(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, 1 + effectiveLeverage);
         if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
             longSpread *= spreadScale;
         }
@@ -247,8 +247,8 @@ function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPc
         }
     }
     else {
-        longSpread *= MAX_INVENTORY_SKEW;
-        shortSpread *= MAX_INVENTORY_SKEW;
+        longSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
+        shortSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
     }
     const totalSpread = longSpread + shortSpread;
     if (totalSpread > maxTargetSpread) {
@@ -268,17 +268,17 @@ function calculateSpread(amm, direction, oraclePriceData) {
     if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
         return amm.baseSpread / 2;
     }
-    const markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
-    const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
+    const reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || reservePrice;
     const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
-    const targetMarkSpreadPct = markPrice
+    const targetMarkSpreadPct = reservePrice
         .sub(targetPrice)
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
-        .div(markPrice);
+        .div(reservePrice);
     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, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
+        .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);
     let spread;
     if ((0, types_1.isVariant)(direction, 'long')) {
         spread = longSpread;
@@ -396,6 +396,9 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oracleP
 }
 exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
 function calculateQuoteAssetAmountSwapped(quoteAssetReserves, pegMultiplier, swapDirection) {
+    if ((0, types_1.isVariant)(swapDirection, 'remove')) {
+        quoteAssetReserves = quoteAssetReserves.add(numericConstants_1.ONE);
+    }
     let quoteAssetAmount = quoteAssetReserves
         .mul(pegMultiplier)
         .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);

package/lib/math/market.d.ts

@@ -24,7 +24,7 @@ export declare function calculateBidPrice(market: PerpMarketAccount, oraclePrice
  */
 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 calculateOracleReserveSpread(market: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): 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;

package/lib/math/market.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
+exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateOracleReserveSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
@@ -50,11 +50,11 @@ function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
     return newMarket;
 }
 exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
-function calculateMarkOracleSpread(market, oraclePriceData) {
-    const markPrice = calculateReservePrice(market, oraclePriceData);
-    return calculateOracleSpread(markPrice, oraclePriceData);
+function calculateOracleReserveSpread(market, oraclePriceData) {
+    const reservePrice = calculateReservePrice(market, oraclePriceData);
+    return calculateOracleSpread(reservePrice, oraclePriceData);
 }
-exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
+exports.calculateOracleReserveSpread = calculateOracleReserveSpread;
 function calculateOracleSpread(price, oraclePriceData) {
     return price.sub(oraclePriceData.price);
 }
@@ -66,7 +66,7 @@ function calculateMarketMarginRatio(market, size, marginCategory) {
             marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, market.imfFactor, new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
         case 'Maintenance':
-            marginRatio = market.marginRatioMaintenance;
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, market.imfFactor, new anchor_1.BN(market.marginRatioMaintenance), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
     }
     return marginRatio;

package/lib/math/spotBalance.js

@@ -115,20 +115,19 @@ exports.calculateUtilization = calculateUtilization;
 function calculateInterestRate(bank) {
     const utilization = calculateUtilization(bank);
     let interestRate;
-    if (utilization.gt(bank.optimalUtilization)) {
-        const surplusUtilization = utilization.sub(bank.optimalUtilization);
-        const borrowRateSlope = bank.maxBorrowRate
-            .sub(bank.optimalBorrowRate)
+    if (utilization.gt(new anchor_1.BN(bank.optimalUtilization))) {
+        const surplusUtilization = utilization.sub(new anchor_1.BN(bank.optimalUtilization));
+        const borrowRateSlope = new anchor_1.BN(bank.maxBorrowRate - bank.optimalBorrowRate)
             .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
-            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-        interestRate = bank.optimalBorrowRate.add(surplusUtilization
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
+        interestRate = new anchor_1.BN(bank.optimalBorrowRate).add(surplusUtilization
             .mul(borrowRateSlope)
             .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION));
     }
     else {
-        const borrowRateSlope = bank.optimalBorrowRate
+        const borrowRateSlope = new anchor_1.BN(bank.optimalBorrowRate)
             .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
-            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
         interestRate = utilization
             .mul(borrowRateSlope)
             .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);

package/lib/math/trade.js

@@ -138,20 +138,20 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     (0, assert_1.assert)(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
     (0, assert_1.assert)(targetPrice.gt(numericConstants_1.ZERO));
     (0, assert_1.assert)(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
-    const markPriceBefore = (0, market_1.calculateReservePrice)(market, oraclePriceData);
+    const reservePriceBefore = (0, market_1.calculateReservePrice)(market, oraclePriceData);
     const bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
     const askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
     let direction;
-    if (targetPrice.gt(markPriceBefore)) {
-        const priceGap = targetPrice.sub(markPriceBefore);
+    if (targetPrice.gt(reservePriceBefore)) {
+        const priceGap = targetPrice.sub(reservePriceBefore);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-        targetPrice = markPriceBefore.add(priceGapScaled);
+        targetPrice = reservePriceBefore.add(priceGapScaled);
         direction = types_1.PositionDirection.LONG;
     }
     else {
-        const priceGap = markPriceBefore.sub(targetPrice);
+        const priceGap = reservePriceBefore.sub(targetPrice);
         const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-        targetPrice = markPriceBefore.sub(priceGapScaled);
+        targetPrice = reservePriceBefore.sub(priceGapScaled);
         direction = types_1.PositionDirection.SHORT;
     }
     let tradeSize;
@@ -179,7 +179,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         targetPrice.lt(askPriceBefore) &&
         targetPrice.gt(bidPriceBefore)) {
         // no trade, market is at target
-        if (markPriceBefore.gt(targetPrice)) {
+        if (reservePriceBefore.gt(targetPrice)) {
             direction = types_1.PositionDirection.SHORT;
         }
         else {
@@ -188,7 +188,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         tradeSize = numericConstants_1.ZERO;
         return [direction, tradeSize, targetPrice, targetPrice];
     }
-    else if (markPriceBefore.gt(targetPrice)) {
+    else if (reservePriceBefore.gt(targetPrice)) {
         // overestimate y2
         baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
         quoteAssetReserveAfter = k.div(numericConstants_1.PRICE_PRECISION).div(baseAssetReserveAfter);
@@ -201,7 +201,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
             .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
         baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
     }
-    else if (markPriceBefore.lt(targetPrice)) {
+    else if (reservePriceBefore.lt(targetPrice)) {
         // underestimate y2
         baseAssetReserveAfter = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
         quoteAssetReserveAfter = k.div(numericConstants_1.PRICE_PRECISION).div(baseAssetReserveAfter);
@@ -222,11 +222,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     let tp1 = targetPrice;
     let tp2 = markPriceAfter;
-    let originalDiff = targetPrice.sub(markPriceBefore);
+    let originalDiff = targetPrice.sub(reservePriceBefore);
     if (direction == types_1.PositionDirection.SHORT) {
         tp1 = markPriceAfter;
         tp2 = targetPrice;
-        originalDiff = markPriceBefore.sub(targetPrice);
+        originalDiff = reservePriceBefore.sub(targetPrice);
     }
     const entryPrice = tradeSize
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)

package/lib/types.d.ts

@@ -1,10 +1,48 @@
 /// <reference types="bn.js" />
 import { PublicKey, Transaction } from '@solana/web3.js';
 import { BN } from '.';
+export declare class ExchangeStatus {
+    static readonly ACTIVE: {
+        active: {};
+    };
+    static readonly FUNDINGPAUSED: {
+        fundingpaused: {};
+    };
+    static readonly AMMPAUSED: {
+        ammpaused: {};
+    };
+    static readonly FILLPAUSED: {
+        fillpaused: {};
+    };
+    static readonly LIQPAUSED: {
+        liqpaused: {};
+    };
+    static readonly WITHDRAWPAUSED: {
+        withdrawpaused: {};
+    };
+    static readonly PAUSED: {
+        paused: {};
+    };
+}
 export declare class MarketStatus {
     static readonly INITIALIZED: {
         initialized: {};
     };
+    static readonly ACTIVE: {
+        active: {};
+    };
+    static readonly FUNDINGPAUSED: {
+        fundingpaused: {};
+    };
+    static readonly AMMPAUSED: {
+        ammpaused: {};
+    };
+    static readonly FILLPAUSED: {
+        fillpaused: {};
+    };
+    static readonly WITHDRAWPAUSED: {
+        withdrawpaused: {};
+    };
     static readonly REDUCEONLY: {
         reduceonly: {};
     };
@@ -23,6 +61,37 @@ export declare class ContractType {
         future: {};
     };
 }
+export declare class ContractTier {
+    static readonly A: {
+        a: {};
+    };
+    static readonly B: {
+        b: {};
+    };
+    static readonly C: {
+        c: {};
+    };
+    static readonly Speculative: {
+        speculative: {};
+    };
+}
+export declare class AssetTier {
+    static readonly COLLATERAL: {
+        collateral: {};
+    };
+    static readonly PROTECTED: {
+        protected: {};
+    };
+    static readonly CROSS: {
+        cross: {};
+    };
+    static readonly ISOLATED: {
+        isolated: {};
+    };
+    static readonly UNLISTED: {
+        unlisted: {};
+    };
+}
 export declare class SwapDirection {
     static readonly ADD: {
         add: {};
@@ -197,9 +266,22 @@ export declare type DepositRecord = {
     marketIndex: number;
     amount: BN;
     oraclePrice: BN;
-    referrer: PublicKey;
-    from?: PublicKey;
-    to?: PublicKey;
+    marketDepositBalance: BN;
+    marketWithdrawBalance: BN;
+    marketCumulativeDepositInterest: BN;
+    marketCumulativeBorrowInterest: BN;
+    transferUser?: PublicKey;
+};
+export declare type SpotInterestRecord = {
+    ts: BN;
+    marketIndex: number;
+    depositBalance: BN;
+    cumulativeDepositInterest: BN;
+    borrowBalance: BN;
+    cumulativeBorrowInterest: BN;
+    optimalUtilization: number;
+    optimalBorrowRate: number;
+    maxBorrowRate: number;
 };
 export declare type CurveRecord = {
     ts: BN;
@@ -224,8 +306,8 @@ export declare type InsuranceFundRecord = {
     ts: BN;
     bankIndex: BN;
     marketIndex: number;
-    userIfFactor: BN;
-    totalIfFactor: BN;
+    userIfFactor: number;
+    totalIfFactor: number;
     vaultAmountBefore: BN;
     insuranceVaultAmountBefore: BN;
     amount: BN;
@@ -276,7 +358,6 @@ export declare type FundingPaymentRecord = {
     fundingPayment: BN;
     baseAssetAmount: BN;
     userLastCumulativeFunding: BN;
-    userLastFundingRateTs: BN;
     ammCumulativeFundingLong: BN;
     ammCumulativeFundingShort: BN;
 };
@@ -290,11 +371,11 @@ export declare type LiquidationRecord = {
     liquidationId: number;
     canceledOrderIds: BN[];
     liquidatePerp: LiquidatePerpRecord;
-    liquidateBorrow: LiquidateBorrowRecord;
+    liquidateSpot: LiquidateSpotRecord;
     liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
     liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
     perpBankruptcy: PerpBankruptcyRecord;
-    borrowBankruptcy: BorrowBankruptcyRecord;
+    spotBankruptcy: SpotBankruptcyRecord;
 };
 export declare class LiquidationType {
     static readonly LIQUIDATE_PERP: {
@@ -322,14 +403,12 @@ export declare type LiquidatePerpRecord = {
     baseAssetAmount: BN;
     quoteAssetAmount: BN;
     lpShares: BN;
-    userPnl: BN;
-    liquidatorPnl: BN;
     userOrderId: BN;
     liquidatorOrderId: BN;
     fillRecordId: BN;
     ifFee: BN;
 };
-export declare type LiquidateBorrowRecord = {
+export declare type LiquidateSpotRecord = {
     assetMarketIndex: number;
     assetPrice: BN;
     assetTransfer: BN;
@@ -359,7 +438,7 @@ export declare type PerpBankruptcyRecord = {
     pnl: BN;
     cumulativeFundingRateDelta: BN;
 };
-export declare type BorrowBankruptcyRecord = {
+export declare type SpotBankruptcyRecord = {
     marketIndex: number;
     borrowAmount: BN;
     cumulativeDepositInterestDelta: BN;
@@ -395,14 +474,14 @@ export declare type OrderActionRecord = {
     referrerReward: number | null;
     quoteAssetAmountSurplus: BN | null;
     taker: PublicKey | null;
-    takerOrderId: BN | null;
+    takerOrderId: number | null;
     takerOrderDirection: PositionDirection | null;
     takerOrderBaseAssetAmount: BN | null;
     takerOrderCumulativeBaseAssetAmountFilled: BN | null;
     takerOrderCumulativeQuoteAssetAmountFilled: BN | null;
     takerOrderFee: BN | null;
     maker: PublicKey | null;
-    makerOrderId: BN | null;
+    makerOrderId: number | null;
     makerOrderDirection: PositionDirection | null;
     makerOrderBaseAssetAmount: BN | null;
     makerOrderCumulativeBaseAssetAmountFilled: BN | null;
@@ -412,24 +491,20 @@ export declare type OrderActionRecord = {
 };
 export declare type StateAccount = {
     admin: PublicKey;
-    fundingPaused: boolean;
-    exchangePaused: boolean;
-    adminControlsPrices: boolean;
-    totalFee: BN;
-    totalFeeWithdrawn: BN;
+    exchangeStatus: ExchangeStatus;
     whitelistMint: PublicKey;
     discountMint: PublicKey;
     oracleGuardRails: OracleGuardRails;
-    maxDeposit: BN;
     numberOfMarkets: number;
     numberOfSpotMarkets: number;
     minOrderQuoteAssetAmount: BN;
-    signer: PublicKey;
-    signerNonce: number;
-    defaultMarketOrderTimeInForce: number;
     minPerpAuctionDuration: number;
+    defaultMarketOrderTimeInForce: number;
     defaultSpotAuctionDuration: number;
     liquidationMarginBufferRatio: number;
+    settlementDuration: number;
+    signer: PublicKey;
+    signerNonce: number;
     srmVault: PublicKey;
     perpFeeStructure: FeeStructure;
     spotFeeStructure: FeeStructure;
@@ -479,6 +554,8 @@ export declare type HistoricalIndexData = {
     lastIndexPriceTwapTs: BN;
 };
 export declare type SpotMarketAccount = {
+    status: MarketStatus;
+    assetTier: AssetTier;
     marketIndex: number;
     pubkey: PublicKey;
     mint: PublicKey;
@@ -492,17 +569,18 @@ export declare type SpotMarketAccount = {
     revenuePool: PoolBalance;
     totalIfShares: BN;
     userIfShares: BN;
-    userIfFactor: BN;
-    totalIfFactor: BN;
+    userIfFactor: number;
+    totalIfFactor: number;
     ifLiquidationFee: BN;
     decimals: number;
-    optimalUtilization: BN;
-    optimalBorrowRate: BN;
-    maxBorrowRate: BN;
+    optimalUtilization: number;
+    optimalBorrowRate: number;
+    maxBorrowRate: number;
     cumulativeDepositInterest: BN;
     cumulativeBorrowInterest: BN;
     depositBalance: BN;
     borrowBalance: BN;
+    maxTokenDeposits: BN;
     lastInterestTs: BN;
     lastTwapTs: BN;
     initialAssetWeight: BN;
@@ -517,13 +595,12 @@ export declare type SpotMarketAccount = {
     utilizationTwap: BN;
     orderStepSize: BN;
     nextFillRecordId: BN;
-    spotFeePool: {
-        balance: BN;
-    };
+    spotFeePool: PoolBalance;
     totalSpotFee: BN;
 };
 export declare type PoolBalance = {
     balance: BN;
+    marketIndex: number;
 };
 export declare type AMM = {
     baseAssetReserve: BN;
@@ -537,7 +614,7 @@ export declare type AMM = {
     oracle: PublicKey;
     oracleSource: OracleSource;
     historicalOracleData: HistoricalOracleData;
-    lastOracleMarkSpreadPct: BN;
+    lastOracleReservePriceSpreadPct: BN;
     lastOracleConfPct: BN;
     fundingPeriod: BN;
     quoteAssetReserve: BN;
@@ -583,7 +660,6 @@ export declare type AMM = {
 };
 export declare type PerpPosition = {
     baseAssetAmount: BN;
-    remainderBaseAssetAmount: BN;
     lastCumulativeFundingRate: BN;
     marketIndex: number;
     quoteAssetAmount: BN;
@@ -593,7 +669,7 @@ export declare type PerpPosition = {
     openAsks: BN;
     settledPnl: BN;
     lpShares: BN;
-    lastFeePerLp: BN;
+    remainderBaseAssetAmount: number;
     lastNetBaseAssetAmountPerLp: BN;
     lastNetQuoteAssetAmountPerLp: BN;
 };
@@ -628,7 +704,7 @@ export declare type UserAccount = {
     beingLiquidated: boolean;
     bankrupt: boolean;
     nextLiquidationId: number;
-    nextOrderId: BN;
+    nextOrderId: number;
     customMarginRatio: number;
 };
 export declare type SpotPosition = {
@@ -646,7 +722,7 @@ export declare type Order = {
     marketType: MarketType;
     ts: BN;
     slot: BN;
-    orderId: BN;
+    orderId: number;
     userOrderId: number;
     marketIndex: number;
     price: BN;
@@ -680,10 +756,10 @@ export declare type OrderParams = {
     reduceOnly: boolean;
     postOnly: boolean;
     immediateOrCancel: boolean;
-    triggerPrice: BN;
+    triggerPrice: BN | null;
     triggerCondition: OrderTriggerCondition;
     positionLimit: BN;
-    oraclePriceOffset: BN;
+    oraclePriceOffset: BN | null;
     auctionDuration: number | null;
     timeInForce: number | null;
     auctionStartPrice: BN | null;
@@ -714,12 +790,12 @@ export declare const DefaultOrderParams: {
     reduceOnly: boolean;
     postOnly: boolean;
     immediateOrCancel: boolean;
-    triggerPrice: BN;
+    triggerPrice: any;
     triggerCondition: {
         above: {};
     };
     positionLimit: BN;
-    oraclePriceOffset: BN;
+    oraclePriceOffset: any;
     auctionDuration: any;
     timeInForce: any;
     auctionStartPrice: any;
@@ -727,6 +803,7 @@ export declare const DefaultOrderParams: {
 export declare type MakerInfo = {
     maker: PublicKey;
     makerStats: PublicKey;
+    makerUserAccount: UserAccount;
     order: Order;
 };
 export declare type TakerInfo = {