@velocity-exchange/sdk 0.0.3 → 0.1.0

package/lib/browser/math/market.js

@@ -15,7 +15,7 @@ const assert_1 = require("../assert/assert");
  * @return markPrice : Precision PRICE_PRECISION
  */
 function calculateReservePrice(market, mmOraclePriceData) {
-    const newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, mmOraclePriceData);
+    const newAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, market.totalExchangeFee, mmOraclePriceData);
     return (0, amm_1.calculatePrice)(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
 }
 exports.calculateReservePrice = calculateReservePrice;
@@ -26,7 +26,7 @@ exports.calculateReservePrice = calculateReservePrice;
  * @return bidPrice : Precision PRICE_PRECISION
  */
 function calculateBidPrice(market, mmOraclePriceData, latestSlot) {
-    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.SHORT, mmOraclePriceData, latestSlot);
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, types_1.PositionDirection.SHORT, mmOraclePriceData, latestSlot);
     return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 exports.calculateBidPrice = calculateBidPrice;
@@ -37,7 +37,7 @@ exports.calculateBidPrice = calculateBidPrice;
  * @return askPrice : Precision PRICE_PRECISION
  */
 function calculateAskPrice(market, mmOraclePriceData, latestSlot) {
-    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, types_1.PositionDirection.LONG, mmOraclePriceData, latestSlot);
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, types_1.PositionDirection.LONG, mmOraclePriceData, latestSlot);
     return (0, amm_1.calculatePrice)(baseAssetReserve, quoteAssetReserve, newPeg);
 }
 exports.calculateAskPrice = calculateAskPrice;
@@ -122,7 +122,7 @@ function calculateNetUserPnl(perpMarket, oraclePriceData) {
         .mul(oraclePriceData.price)
         .div(numericConstants_1.BASE_PRECISION)
         .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
-    const netUserCostBasis = perpMarket.amm.quoteAssetAmount.add(perpMarket.amm.netUnsettledFundingPnl);
+    const netUserCostBasis = perpMarket.quoteAssetAmount.add(perpMarket.netUnsettledFundingPnl);
     const netUserPnl = netUserPositionValue.add(netUserCostBasis);
     return netUserPnl;
 }
@@ -139,7 +139,7 @@ function calculateNetUserPnlImbalance(perpMarket, spotMarket, oraclePriceData, a
 }
 exports.calculateNetUserPnlImbalance = calculateNetUserPnlImbalance;
 function calculateAvailablePerpLiquidity(market, mmOraclePriceData, dlob, slot) {
-    let [bids, asks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
+    let [bids, asks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.orderStepSize);
     asks = asks.abs();
     for (const bid of dlob.getRestingLimitBids(market.marketIndex, slot, types_1.MarketType.PERP, mmOraclePriceData)) {
         bids = bids.add(bid.order.baseAssetAmount.sub(bid.order.baseAssetAmountFilled));
@@ -172,8 +172,8 @@ function getTriggerPrice(market, oraclePrice, now, useMedianPrice) {
     }
     const lastFillPrice = market.lastFillPrice;
     // Calculate 5-minute basis
-    const markPrice5minTwap = market.amm.lastMarkPriceTwap5Min;
-    const lastOraclePriceTwap5min = market.amm.historicalOracleData.lastOraclePriceTwap5Min;
+    const markPrice5minTwap = market.marketStats.lastMarkPriceTwap5Min;
+    const lastOraclePriceTwap5min = market.marketStats.historicalOracleData.lastOraclePriceTwap5Min;
     const basis5min = markPrice5minTwap.sub(lastOraclePriceTwap5min);
     const oraclePlusBasis5min = oraclePrice.add(basis5min);
     // Calculate funding basis
@@ -193,19 +193,19 @@ exports.getTriggerPrice = getTriggerPrice;
  * Implements the same logic as the Rust get_last_funding_basis function
  */
 function getLastFundingBasis(market, oraclePrice, now) {
-    if (market.amm.lastFundingOracleTwap.gt(numericConstants_1.ZERO)) {
-        const lastFundingRate = market.amm.lastFundingRate
+    if (market.lastFundingOracleTwap.gt(numericConstants_1.ZERO)) {
+        const lastFundingRate = market.lastFundingRate
             .mul(numericConstants_1.PRICE_PRECISION)
-            .div(market.amm.lastFundingOracleTwap)
+            .div(market.lastFundingOracleTwap)
             .muln(24);
         const lastFundingRatePreAdj = lastFundingRate.sub(numericConstants_1.FUNDING_RATE_PRECISION.div(new anchor_1.BN(3333)) // FUNDING_RATE_OFFSET_PERCENTAGE
         );
-        const timeLeftUntilFundingUpdate = anchor_1.BN.min(anchor_1.BN.max(now.sub(market.amm.lastFundingRateTs), numericConstants_1.ZERO), market.amm.fundingPeriod);
+        const timeLeftUntilFundingUpdate = anchor_1.BN.min(anchor_1.BN.max(now.sub(market.lastFundingRateTs), numericConstants_1.ZERO), market.marketStats.fundingPeriod);
         const lastFundingBasis = oraclePrice
             .mul(lastFundingRatePreAdj)
             .div(numericConstants_1.PERCENTAGE_PRECISION)
-            .mul(market.amm.fundingPeriod.sub(timeLeftUntilFundingUpdate))
-            .div(market.amm.fundingPeriod)
+            .mul(market.marketStats.fundingPeriod.sub(timeLeftUntilFundingUpdate))
+            .div(market.marketStats.fundingPeriod)
             .div(new anchor_1.BN(1000)); // FUNDING_RATE_BUFFER
         return lastFundingBasis;
     }

package/lib/browser/math/oracles.d.ts

@@ -1,17 +1,17 @@
 /// <reference types="bn.js" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { AMM, HistoricalOracleData, OracleGuardRails, OracleSource, OracleValidity, PerpMarketAccount } from '../types';
+import { HistoricalOracleData, MarketStats, OracleGuardRails, OracleSource, OracleValidity, PerpMarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import { BN } from '../isomorphic/anchor';
 export declare function oraclePriceBands(market: PerpMarketAccount, oraclePriceData: Pick<OraclePriceData, 'price'>): [BN, BN];
 export declare function getMaxConfidenceIntervalMultiplier(market: PerpMarketAccount): BN;
 export declare function getOracleValidity(market: PerpMarketAccount, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: BN, oracleStalenessBuffer?: BN): OracleValidity;
 export declare function isOracleValid(market: PerpMarketAccount, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
-export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails): boolean;
+export declare function isOracleTooDivergent(marketStats: MarketStats, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails): boolean;
 export declare function calculateLiveOracleTwap(histOracleData: HistoricalOracleData, oraclePriceData: OraclePriceData, now: BN, period: BN): BN;
-export declare function calculateLiveOracleStd(amm: AMM, oraclePriceData: OraclePriceData, now: BN): BN;
-export declare function getNewOracleConfPct(amm: AMM, oraclePriceData: OraclePriceData, reservePrice: BN, now: BN): BN;
+export declare function calculateLiveOracleStd(marketStats: MarketStats, oraclePriceData: OraclePriceData, now: BN): BN;
+export declare function getNewOracleConfPct(marketStats: MarketStats, oraclePriceData: OraclePriceData, reservePrice: BN, now: BN): BN;
 export declare function trimVaaSignatures(vaa: Buffer, n?: number): Buffer;
 export declare function getMultipleBetweenOracleSources(firstOracleSource: OracleSource, secondOracleSource: OracleSource): {
     numerator: BN;

package/lib/browser/math/oracles.js

@@ -36,8 +36,8 @@ function getMaxConfidenceIntervalMultiplier(market) {
 exports.getMaxConfidenceIntervalMultiplier = getMaxConfidenceIntervalMultiplier;
 function getOracleValidity(market, oraclePriceData, oracleGuardRails, slot, oracleStalenessBuffer = numericConstants_1.FIVE) {
     const isNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
-    const isTooVolatile = anchor_1.BN.max(oraclePriceData.price, market.amm.historicalOracleData.lastOraclePriceTwap)
-        .div(anchor_1.BN.max(numericConstants_1.ONE, anchor_1.BN.min(oraclePriceData.price, market.amm.historicalOracleData.lastOraclePriceTwap)))
+    const isTooVolatile = anchor_1.BN.max(oraclePriceData.price, market.marketStats.historicalOracleData.lastOraclePriceTwap)
+        .div(anchor_1.BN.max(numericConstants_1.ONE, anchor_1.BN.min(oraclePriceData.price, market.marketStats.historicalOracleData.lastOraclePriceTwap)))
         .gt(oracleGuardRails.validity.tooVolatileRatio);
     const confPctOfPrice = oraclePriceData.confidence
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
@@ -45,18 +45,18 @@ function getOracleValidity(market, oraclePriceData, oracleGuardRails, slot, orac
     const isConfTooLarge = confPctOfPrice.gt(oracleGuardRails.validity.confidenceIntervalMaxSize.mul(getMaxConfidenceIntervalMultiplier(market)));
     const oracleDelay = slot.sub(oraclePriceData.slot).sub(oracleStalenessBuffer);
     let isStaleForAmmImmediate = true;
-    if (market.amm.oracleSlotDelayOverride != 0) {
-        isStaleForAmmImmediate = oracleDelay.gt(anchor_1.BN.max(new anchor_1.BN(market.amm.oracleSlotDelayOverride), numericConstants_1.ZERO));
+    if (market.oracleSlotDelayOverride != 0) {
+        isStaleForAmmImmediate = oracleDelay.gt(anchor_1.BN.max(new anchor_1.BN(market.oracleSlotDelayOverride), numericConstants_1.ZERO));
     }
     let isStaleForAmmLowRisk = false;
-    if (market.amm.oracleLowRiskSlotDelayOverride != 0) {
-        isStaleForAmmLowRisk = oracleDelay.gt(anchor_1.BN.max(new anchor_1.BN(market.amm.oracleLowRiskSlotDelayOverride), numericConstants_1.ZERO));
+    if (market.oracleLowRiskSlotDelayOverride != 0) {
+        isStaleForAmmLowRisk = oracleDelay.gt(anchor_1.BN.max(new anchor_1.BN(market.oracleLowRiskSlotDelayOverride), numericConstants_1.ZERO));
     }
     else {
         isStaleForAmmLowRisk = oracleDelay.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
     }
     let isStaleForMargin = oracleDelay.gt(new anchor_1.BN(oracleGuardRails.validity.slotsBeforeStaleForMargin));
-    if ((0, types_1.isVariant)(market.amm.oracleSource, 'pythLazerStableCoin')) {
+    if ((0, types_1.isVariant)(market.oracleSource, 'pythLazerStableCoin')) {
         isStaleForMargin = oracleDelay.gt(new anchor_1.BN(oracleGuardRails.validity.slotsBeforeStaleForMargin).muln(3));
     }
     if (isNonPositive) {
@@ -87,12 +87,12 @@ function getOracleValidity(market, oraclePriceData, oracleGuardRails, slot, orac
 exports.getOracleValidity = getOracleValidity;
 function isOracleValid(market, oraclePriceData, oracleGuardRails, slot) {
     // checks if oracle is valid for an AMM only fill
-    const amm = market.amm;
+    const stats = market.marketStats;
     const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price
-        .div(anchor_1.BN.max(numericConstants_1.ONE, amm.historicalOracleData.lastOraclePriceTwap))
+        .div(anchor_1.BN.max(numericConstants_1.ONE, stats.historicalOracleData.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
-        amm.historicalOracleData.lastOraclePriceTwap
+        stats.historicalOracleData.lastOraclePriceTwap
             .div(anchor_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
             .gt(oracleGuardRails.validity.tooVolatileRatio);
     const maxConfidenceIntervalMultiplier = getMaxConfidenceIntervalMultiplier(market);
@@ -110,11 +110,11 @@ function isOracleValid(market, oraclePriceData, oracleGuardRails, slot) {
         isConfidenceTooLarge);
 }
 exports.isOracleValid = isOracleValid;
-function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails) {
+function isOracleTooDivergent(marketStats, oraclePriceData, oracleGuardRails) {
     const oracleSpreadPct = oraclePriceData.price
-        .sub(amm.historicalOracleData.lastOraclePriceTwap5Min)
+        .sub(marketStats.historicalOracleData.lastOraclePriceTwap5Min)
         .mul(numericConstants_1.PERCENTAGE_PRECISION)
-        .div(amm.historicalOracleData.lastOraclePriceTwap5Min);
+        .div(marketStats.historicalOracleData.lastOraclePriceTwap5Min);
     const maxDivergence = anchor_1.BN.max(oracleGuardRails.priceDivergence.oracleTwap5MinPercentDivergence, numericConstants_1.PERCENTAGE_PRECISION.div(new anchor_1.BN(2)));
     const tooDivergent = oracleSpreadPct.abs().gte(maxDivergence);
     return tooDivergent;
@@ -141,23 +141,23 @@ function calculateLiveOracleTwap(histOracleData, oraclePriceData, now, period) {
     return newOracleTwap;
 }
 exports.calculateLiveOracleTwap = calculateLiveOracleTwap;
-function calculateLiveOracleStd(amm, oraclePriceData, now) {
-    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
-    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
-    const liveOracleTwap = calculateLiveOracleTwap(amm.historicalOracleData, oraclePriceData, now, amm.fundingPeriod);
-    const liveOracleTwap5MIN = calculateLiveOracleTwap(amm.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE);
+function calculateLiveOracleStd(marketStats, oraclePriceData, now) {
+    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ONE, now.sub(marketStats.historicalOracleData.lastOraclePriceTwapTs));
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, marketStats.fundingPeriod.sub(sinceLastUpdate));
+    const liveOracleTwap = calculateLiveOracleTwap(marketStats.historicalOracleData, oraclePriceData, now, marketStats.fundingPeriod);
+    const liveOracleTwap5MIN = calculateLiveOracleTwap(marketStats.historicalOracleData, oraclePriceData, now, numericConstants_1.FIVE_MINUTE);
     const priceDeltaVsTwap = anchor_1.BN.max(oraclePriceData.price.sub(liveOracleTwap).abs(), oraclePriceData.price.sub(liveOracleTwap5MIN).abs());
-    const oracleStd = priceDeltaVsTwap.add(amm.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate)));
+    const oracleStd = priceDeltaVsTwap.add(marketStats.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate)));
     return oracleStd;
 }
 exports.calculateLiveOracleStd = calculateLiveOracleStd;
-function getNewOracleConfPct(amm, oraclePriceData, reservePrice, now) {
+function getNewOracleConfPct(marketStats, oraclePriceData, reservePrice, now) {
     const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
-    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ZERO, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
-    let lowerBoundConfPct = amm.lastOracleConfPct;
+    const sinceLastUpdate = anchor_1.BN.max(numericConstants_1.ZERO, now.sub(marketStats.historicalOracleData.lastOraclePriceTwapTs));
+    let lowerBoundConfPct = marketStats.lastOracleConfPct;
     if (sinceLastUpdate.gt(numericConstants_1.ZERO)) {
         const lowerBoundConfDivisor = anchor_1.BN.max(new anchor_1.BN(21).sub(sinceLastUpdate), new anchor_1.BN(5));
-        lowerBoundConfPct = amm.lastOracleConfPct.sub(amm.lastOracleConfPct.div(lowerBoundConfDivisor));
+        lowerBoundConfPct = marketStats.lastOracleConfPct.sub(marketStats.lastOracleConfPct.div(lowerBoundConfDivisor));
     }
     const confIntervalPct = confInterval
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)

package/lib/browser/math/orders.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { User } from '../user';
-import { PerpMarketAccount, AMM, Order, PositionDirection, MarketTypeStr, StateAccount } from '../types';
+import { PerpMarketAccount, AMM, MarketStats, Order, PositionDirection, MarketTypeStr, StateAccount } from '../types';
 import { BN } from '../isomorphic/anchor';
 import { MMOraclePriceData, OraclePriceData } from '../oracles/types';
 export declare function isOrderRiskIncreasing(user: User, order: Order): boolean;
@@ -14,7 +14,7 @@ export declare function hasAuctionPrice(order: Order, slot: number): boolean;
 export declare function isFillableByVAMM(order: Order, market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, slot: number, ts: number, state: StateAccount): boolean;
 export declare function isLowRiskForAmm(order: Order, mmOraclePriceData: MMOraclePriceData, isLiquidation?: boolean): boolean;
 export declare function calculateBaseAssetAmountForAmmToFulfill(order: Order, market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, slot: number): BN;
-export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, amm: AMM, limitPrice: BN, mmOraclePriceData: MMOraclePriceData): BN;
+export declare function calculateBaseAssetAmountToFillUpToLimitPrice(order: Order, amm: AMM, marketStats: MarketStats, orderStepSize: BN, orderTickSize: BN, limitPrice: BN, mmOraclePriceData: MMOraclePriceData): BN;
 export declare function isOrderExpired(order: Order, ts: number, enforceBuffer?: boolean, bufferSeconds?: number): boolean;
 export declare function isMarketOrder(order: Order): boolean;
 export declare function isLimitOrder(order: Order): boolean;

package/lib/browser/math/orders.js

@@ -101,8 +101,8 @@ function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
     if (hasAuctionPrice(order, slot)) {
         return (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
     }
-    else if (order.oraclePriceOffset !== 0) {
-        return anchor_1.BN.max(oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset)), numericConstants_1.ONE);
+    else if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        return anchor_1.BN.max(oraclePriceData.price.add(order.oraclePriceOffset), numericConstants_1.ONE);
     }
     else if (order.price.eq(numericConstants_1.ZERO)) {
         return fallbackPrice;
@@ -114,7 +114,7 @@ function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
 exports.getLimitPrice = getLimitPrice;
 function hasLimitPrice(order, slot) {
     return (order.price.gt(numericConstants_1.ZERO) ||
-        order.oraclePriceOffset != 0 ||
+        !order.oraclePriceOffset.eq(numericConstants_1.ZERO) ||
         !(0, auction_1.isAuctionComplete)(order, slot));
 }
 exports.hasLimitPrice = hasLimitPrice;
@@ -145,23 +145,23 @@ function calculateBaseAssetAmountForAmmToFulfill(order, market, mmOraclePriceDat
     }
     const limitPrice = getLimitPrice(order, mmOraclePriceData, slot);
     let baseAssetAmount;
-    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, mmOraclePriceData);
+    const updatedAMM = (0, amm_1.calculateUpdatedAMM)(market.amm, market.totalExchangeFee, mmOraclePriceData);
     if (limitPrice !== undefined) {
-        baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, limitPrice, mmOraclePriceData);
+        baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(order, updatedAMM, market.marketStats, market.orderStepSize, market.orderTickSize, limitPrice, mmOraclePriceData);
     }
     else {
         baseAssetAmount = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
     }
-    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, order.direction);
+    const maxBaseAssetAmount = (0, amm_1.calculateMaxBaseAssetAmountFillable)(updatedAMM, market.orderStepSize, order.direction);
     return anchor_1.BN.min(maxBaseAssetAmount, baseAssetAmount);
 }
 exports.calculateBaseAssetAmountForAmmToFulfill = calculateBaseAssetAmountForAmmToFulfill;
-function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, limitPrice, mmOraclePriceData) {
+function calculateBaseAssetAmountToFillUpToLimitPrice(order, amm, marketStats, orderStepSize, orderTickSize, limitPrice, mmOraclePriceData) {
     const adjustedLimitPrice = (0, types_1.isVariant)(order.direction, 'long')
-        ? limitPrice.sub(amm.orderTickSize)
-        : limitPrice.add(amm.orderTickSize);
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, adjustedLimitPrice, order.direction, mmOraclePriceData);
-    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, amm.orderStepSize);
+        ? limitPrice.sub(orderTickSize)
+        : limitPrice.add(orderTickSize);
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(amm, marketStats, adjustedLimitPrice, order.direction, mmOraclePriceData);
+    const baseAssetAmount = standardizeBaseAssetAmount(maxAmountToTrade, orderStepSize);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {
@@ -285,7 +285,7 @@ function maxSizeForTargetLiabilityWeightBN(target, imfFactor, liabilityWeight, m
         }
     }
     // cap at max OI
-    const maxOpenInterest = market.amm.maxOpenInterest;
+    const maxOpenInterest = market.maxOpenInterest;
     if (lo.gt(maxOpenInterest)) {
         return maxOpenInterest;
     }

package/lib/browser/math/position.js

@@ -23,7 +23,7 @@ function calculateBaseAssetValue(market, userPosition, mmOraclePriceData, useSpr
     let prepegAmm;
     if (!skipUpdate) {
         if (market.amm.baseSpread > 0 && useSpread) {
-            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, mmOraclePriceData, latestSlot);
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, directionToClose, mmOraclePriceData, latestSlot);
             prepegAmm = {
                 baseAssetReserve,
                 quoteAssetReserve,
@@ -32,7 +32,7 @@ function calculateBaseAssetValue(market, userPosition, mmOraclePriceData, useSpr
             };
         }
         else {
-            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, mmOraclePriceData);
+            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, market.totalExchangeFee, mmOraclePriceData);
         }
     }
     else {
@@ -124,10 +124,10 @@ function calculateUnsettledFundingPnl(market, perpPosition) {
     }
     let ammCumulativeFundingRate;
     if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+        ammCumulativeFundingRate = market.cumulativeFundingRateLong;
     }
     else {
-        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+        ammCumulativeFundingRate = market.cumulativeFundingRateShort;
     }
     const perPositionFundingRate = ammCumulativeFundingRate
         .sub(perpPosition.lastCumulativeFundingRate)

package/lib/browser/math/superStake.d.ts

@@ -29,13 +29,11 @@ export type BSOL_EMISSIONS_API_RESPONSE = {
 };
 export declare function fetchBSolMetrics(): Promise<any>;
 export declare function fetchBSolVelocityEmissions(): Promise<any>;
-/** @deprecated Use `fetchBSolVelocityEmissions` instead. `fetchBSolDriftEmissions` will be removed in a future major. */
-export declare const fetchBSolDriftEmissions: typeof fetchBSolVelocityEmissions;
-export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
+export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, velocityClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
     marketIndex: number;
     amount: BN;
     jupiterClient: JupiterClient;
-    driftClient: VelocityClient;
+    velocityClient: VelocityClient;
     price?: number;
     userAccountPublicKey?: PublicKey;
     forceMarinade?: boolean;
@@ -47,10 +45,10 @@ export declare function findBestSuperStakeIxs({ marketIndex, amount, jupiterClie
     method: 'jupiter' | 'marinade';
     price?: number;
 }>;
-export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
+export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }: {
     amount: BN;
     jupiterClient: JupiterClient;
-    driftClient: VelocityClient;
+    velocityClient: VelocityClient;
     price?: number;
     userAccountPublicKey?: PublicKey;
     forceMarinade?: boolean;
@@ -62,10 +60,10 @@ export declare function findBestMSolSuperStakeIxs({ amount, jupiterClient, drift
     method: 'jupiter' | 'marinade';
     price: number;
 }>;
-export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, jupiterQuote, }: {
+export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, onlyDirectRoutes, jupiterQuote, }: {
     amount: BN;
     jupiterClient: JupiterClient;
-    driftClient: VelocityClient;
+    velocityClient: VelocityClient;
     userAccountPublicKey?: PublicKey;
     onlyDirectRoutes?: boolean;
     jupiterQuote?: QuoteResponse;
@@ -80,12 +78,12 @@ export declare function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, dr
  *
  * Without doing any extra steps like checking if you can get a better rate by staking directly with that LST platform
  */
-export declare function findBestLstSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }: {
+export declare function findBestLstSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }: {
     amount: BN;
     lstMint: PublicKey;
     lstMarketIndex: number;
     jupiterClient: JupiterClient;
-    driftClient: VelocityClient;
+    velocityClient: VelocityClient;
     userAccountPublicKey?: PublicKey;
     onlyDirectRoutes?: boolean;
     jupiterQuote?: QuoteResponse;

package/lib/browser/math/superStake.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateEstimatedSuperStakeLiquidationPrice = exports.calculateSolEarned = exports.fetchMSolMetrics = exports.fetchJitoSolMetrics = exports.findBestLstSuperStakeIxs = exports.findBestJitoSolSuperStakeIxs = exports.findBestMSolSuperStakeIxs = exports.findBestSuperStakeIxs = exports.fetchBSolDriftEmissions = exports.fetchBSolVelocityEmissions = exports.fetchBSolMetrics = void 0;
+exports.calculateEstimatedSuperStakeLiquidationPrice = exports.calculateSolEarned = exports.fetchMSolMetrics = exports.fetchJitoSolMetrics = exports.findBestLstSuperStakeIxs = exports.findBestJitoSolSuperStakeIxs = exports.findBestMSolSuperStakeIxs = exports.findBestSuperStakeIxs = exports.fetchBSolVelocityEmissions = exports.fetchBSolMetrics = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const marinade_1 = require("../marinade");
 const anchor_1 = require("../isomorphic/anchor");
@@ -16,17 +16,15 @@ async function fetchBSolMetrics() {
 }
 exports.fetchBSolMetrics = fetchBSolMetrics;
 async function fetchBSolVelocityEmissions() {
-    return await (0, node_fetch_1.default)('https://stake.solblaze.org/api/v1/drift_emissions');
+    return await (0, node_fetch_1.default)('https://stake.solblaze.org/api/v1/velocity_emissions');
 }
 exports.fetchBSolVelocityEmissions = fetchBSolVelocityEmissions;
-/** @deprecated Use `fetchBSolVelocityEmissions` instead. `fetchBSolDriftEmissions` will be removed in a future major. */
-exports.fetchBSolDriftEmissions = fetchBSolVelocityEmissions;
-async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }) {
+async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, velocityClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }) {
     if (marketIndex === 2) {
         return findBestMSolSuperStakeIxs({
             amount,
             jupiterClient,
-            driftClient,
+            velocityClient,
             userAccountPublicKey,
             price,
             forceMarinade,
@@ -38,7 +36,7 @@ async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, drift
         return findBestJitoSolSuperStakeIxs({
             amount,
             jupiterClient,
-            driftClient,
+            velocityClient,
             userAccountPublicKey,
             onlyDirectRoutes,
             jupiterQuote,
@@ -47,10 +45,10 @@ async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, drift
     else if (marketIndex === 8) {
         return findBestLstSuperStakeIxs({
             amount,
-            lstMint: driftClient.getSpotMarketAccount(8).mint,
+            lstMint: velocityClient.getSpotMarketAccount(8).mint,
             lstMarketIndex: 8,
             jupiterClient,
-            driftClient,
+            velocityClient,
             userAccountPublicKey,
             onlyDirectRoutes,
             jupiterQuote,
@@ -61,13 +59,13 @@ async function findBestSuperStakeIxs({ marketIndex, amount, jupiterClient, drift
     }
 }
 exports.findBestSuperStakeIxs = findBestSuperStakeIxs;
-async function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }) {
+async function findBestMSolSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, price, forceMarinade, onlyDirectRoutes, jupiterQuote, }) {
     if (!price) {
-        const marinadeProgram = (0, marinade_1.getMarinadeFinanceProgram)(driftClient.provider);
+        const marinadeProgram = (0, marinade_1.getMarinadeFinanceProgram)(velocityClient.provider);
         price = await (0, marinade_1.getMarinadeMSolPrice)(marinadeProgram);
     }
-    const solSpotMarketAccount = driftClient.getSpotMarketAccount(1);
-    const mSolSpotMarketAccount = driftClient.getSpotMarketAccount(2);
+    const solSpotMarketAccount = velocityClient.getSpotMarketAccount(1);
+    const mSolSpotMarketAccount = velocityClient.getSpotMarketAccount(2);
     let jupiterPrice;
     let quote = jupiterQuote;
     if (!jupiterQuote) {
@@ -87,7 +85,7 @@ async function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, u
         }
     }
     if (!jupiterPrice || price <= jupiterPrice || forceMarinade) {
-        const ixs = await driftClient.getStakeForMSOLIx({
+        const ixs = await velocityClient.getStakeForMSOLIx({
             amount,
             userAccountPublicKey,
         });
@@ -99,7 +97,7 @@ async function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, u
         };
     }
     else {
-        const { ixs, lookupTables } = await driftClient.getJupiterSwapIxV6({
+        const { ixs, lookupTables } = await velocityClient.getJupiterSwapIxV6({
             inMarketIndex: 1,
             outMarketIndex: 2,
             jupiterClient,
@@ -117,14 +115,14 @@ async function findBestMSolSuperStakeIxs({ amount, jupiterClient, driftClient, u
     }
 }
 exports.findBestMSolSuperStakeIxs = findBestMSolSuperStakeIxs;
-async function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, jupiterQuote, }) {
+async function findBestJitoSolSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, onlyDirectRoutes, jupiterQuote, }) {
     return await findBestLstSuperStakeIxs({
         amount,
         jupiterClient,
-        driftClient,
+        velocityClient,
         userAccountPublicKey,
         onlyDirectRoutes,
-        lstMint: driftClient.getSpotMarketAccount(6).mint,
+        lstMint: velocityClient.getSpotMarketAccount(6).mint,
         lstMarketIndex: 6,
         jupiterQuote,
     });
@@ -135,8 +133,8 @@ exports.findBestJitoSolSuperStakeIxs = findBestJitoSolSuperStakeIxs;
  *
  * Without doing any extra steps like checking if you can get a better rate by staking directly with that LST platform
  */
-async function findBestLstSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }) {
-    const { ixs, lookupTables } = await driftClient.getJupiterSwapIxV6({
+async function findBestLstSuperStakeIxs({ amount, jupiterClient, velocityClient, userAccountPublicKey, onlyDirectRoutes, lstMarketIndex, jupiterQuote, }) {
+    const { ixs, lookupTables } = await velocityClient.getJupiterSwapIxV6({
         inMarketIndex: 1,
         outMarketIndex: lstMarketIndex,
         jupiterClient,

package/lib/browser/math/trade.js

@@ -53,7 +53,7 @@ function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quo
         .div(acquiredBaseReserve.abs());
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, mmOraclePriceData, latestSlot);
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, direction, mmOraclePriceData, latestSlot);
         amm = {
             baseAssetReserve,
             quoteAssetReserve,
@@ -102,7 +102,7 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     const swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
     let amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, mmOraclePriceData, latestSlot);
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, direction, mmOraclePriceData, latestSlot);
         amm = {
             baseAssetReserve,
             quoteAssetReserve,
@@ -166,7 +166,7 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     let quoteAssetReserveBefore;
     let peg = market.amm.pegMultiplier;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, mmOraclePriceData, latestSlot);
+        const { baseAssetReserve, quoteAssetReserve, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, direction, mmOraclePriceData, latestSlot);
         baseAssetReserveBefore = baseAssetReserve;
         quoteAssetReserveBefore = quoteAssetReserve;
         peg = newPeg;
@@ -280,14 +280,14 @@ function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market,
     const takerIsLong = (0, types_2.isVariant)(direction, 'long');
     const limitOrders = dlob[takerIsLong ? 'getRestingLimitAsks' : 'getRestingLimitBids'](market.marketIndex, slot, types_1.MarketType.PERP, mmOraclePriceData);
     const swapDirection = (0, amm_1.getSwapDirection)(assetType, direction);
-    const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, mmOraclePriceData, new anchor_1.BN(slot));
+    const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, market.marketStats, market.totalExchangeFee, direction, mmOraclePriceData, new anchor_1.BN(slot));
     const amm = {
         baseAssetReserve,
         quoteAssetReserve,
         sqrtK: sqrtK,
         pegMultiplier: newPeg,
     };
-    const [ammBids, ammAsks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.amm.orderStepSize);
+    const [ammBids, ammAsks] = (0, amm_1.calculateMarketOpenBidAsk)(market.amm.baseAssetReserve, market.amm.minBaseAssetReserve, market.amm.maxBaseAssetReserve, market.orderStepSize);
     let ammLiquidity;
     if (assetType === 'base') {
         ammLiquidity = takerIsLong ? ammAsks.abs() : ammBids;

package/lib/browser/math/utils.d.ts

@@ -18,6 +18,6 @@ export declare function isBNSafe(number: number): boolean;
 /**
  * Converts a number to BN makes sure the number is safe to convert to BN (that it does not overflow number after multiplying by precision)
  * @param number the number to convert to BN
- * @param precision the BN precision to use (i.e. QUOTE_PRECISION and BASE_PRECISION from drift sdk)
+ * @param precision the BN precision to use (i.e. QUOTE_PRECISION and BASE_PRECISION from velocity sdk)
  */
 export declare function numberToSafeBN(number: number, precision: BN): BN;

package/lib/browser/math/utils.js

@@ -93,7 +93,7 @@ exports.isBNSafe = isBNSafe;
 /**
  * Converts a number to BN makes sure the number is safe to convert to BN (that it does not overflow number after multiplying by precision)
  * @param number the number to convert to BN
- * @param precision the BN precision to use (i.e. QUOTE_PRECISION and BASE_PRECISION from drift sdk)
+ * @param precision the BN precision to use (i.e. QUOTE_PRECISION and BASE_PRECISION from velocity sdk)
  */
 function numberToSafeBN(number, precision) {
     // check if number has decimals

package/lib/browser/oracles/pythLazerClient.js

@@ -8,7 +8,7 @@ const web3_js_1 = require("@solana/web3.js");
 const anchor_1 = require("../isomorphic/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const wallet_1 = require("../wallet");
-const drift_json_1 = __importDefault(require("../idl/drift.json"));
+const velocity_json_1 = __importDefault(require("../idl/velocity.json"));
 class PythLazerClient {
     constructor(connection, multiple = numericConstants_1.ONE, stableCoin = false) {
         this.connection = connection;
@@ -19,7 +19,7 @@ class PythLazerClient {
         new wallet_1.Wallet(new web3_js_1.Keypair()), {
             commitment: connection.commitment,
         });
-        this.program = new anchor_1.Program(drift_json_1.default, provider);
+        this.program = new anchor_1.Program(velocity_json_1.default, provider);
         this.decodeFunc = this.program.account.pythLazerOracle.coder.accounts.decodeUnchecked.bind(this.program.account.pythLazerOracle.coder.accounts);
     }
     async getOraclePriceData(pricePublicKey) {

package/lib/browser/orderSubscriber/OrderSubscriber.d.ts

@@ -14,8 +14,6 @@ import { EventEmitter } from 'events';
 import { grpcSubscription } from './grpcSubscription';
 export declare class OrderSubscriber {
     velocityClient: VelocityClient;
-    /** @deprecated Use `velocityClient` instead. `driftClient` will be removed in a future major. */
-    get driftClient(): VelocityClient;
     usersAccounts: Map<string, {
         slot: number;
         userAccount: UserAccount;