@velocity-exchange/sdk 0.0.1

package/lib/node/math/trade.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="bn.js" />
+import { PerpMarketAccount, PositionDirection, UserStatsAccount } from '../types';
+import { BN } from '../isomorphic/anchor';
+import { AssetType } from './amm';
+import { MMOraclePriceData } from '../oracles/types';
+import { DLOB } from '../dlob/DLOB';
+import { PublicKey } from '@solana/web3.js';
+import { L2OrderBook } from '../dlob/orderBookLevels';
+export type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
+/**
+ * Calculates avg/max slippage (price impact) for candidate trade
+ *
+ * @deprecated use calculateEstimatedPerpEntryPrice instead
+ *
+ * @param direction
+ * @param amount
+ * @param market
+ * @param inputAssetType which asset is being traded
+ * @param useSpread whether to consider spread with calculating slippage
+ * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
+ *
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
+ *
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
+ *
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
+ *
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
+ */
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType: AssetType, mmOraclePriceData: MMOraclePriceData, useSpread?: boolean, latestSlot?: BN): [BN, BN, BN, BN];
+/**
+ * Calculates acquired amounts for trade executed
+ * @param direction
+ * @param amount
+ * @param market
+ * @param inputAssetType
+ * @param useSpread
+ * @return
+ * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
+ * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
+ */
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType: AssetType, mmOraclePriceData: MMOraclePriceData, useSpread?: boolean, latestSlot?: BN): [BN, BN, BN];
+/**
+ * calculateTargetPriceTrade
+ * simple function for finding arbitraging trades
+ *
+ * @deprecated
+ *
+ * @param market
+ * @param targetPrice
+ * @param pct optional default is 100% gap filling, can set smaller.
+ * @param outputAssetType which asset to trade.
+ * @param useSpread whether or not to consider the spread when calculating the trade size
+ * @returns trade direction/size in order to push price to a targetPrice,
+ *
+ * [
+ *   direction => direction of trade required, PositionDirection
+ *   tradeSize => size of trade required, TODO-PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
+ * ]
+ */
+export declare function calculateTargetPriceTrade(market: PerpMarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, mmOraclePriceData?: MMOraclePriceData, useSpread?: boolean, latestSlot?: BN): [PositionDirection, BN, BN, BN];
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or vamm)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param slot
+ * @param usersToSkip
+ */
+export declare function calculateEstimatedPerpEntryPrice(assetType: AssetType, amount: BN, direction: PositionDirection, market: PerpMarketAccount, mmOraclePriceData: MMOraclePriceData, dlob: DLOB, slot: number, usersToSkip?: Map<PublicKey, boolean>): {
+    entryPrice: BN;
+    priceImpact: BN;
+    bestPrice: BN;
+    worstPrice: BN;
+    baseFilled: BN;
+    quoteFilled: BN;
+};
+export declare function calculateEstimatedEntryPriceWithL2(assetType: AssetType, amount: BN, direction: PositionDirection, basePrecision: BN, l2: L2OrderBook): {
+    entryPrice: BN;
+    priceImpact: BN;
+    bestPrice: BN;
+    worstPrice: BN;
+    baseFilled: BN;
+    quoteFilled: BN;
+};
+export declare function getUser30dRollingVolumeEstimate(userStatsAccount: UserStatsAccount, now?: BN): BN;
+//# sourceMappingURL=trade.d.ts.map

package/lib/node/math/trade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trade.d.ts","sourceRoot":"","sources":["../../../src/math/trade.ts"],"names":[],"mappings":";AAAA,OAAO,EAEN,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAe1C,OAAO,EAIN,SAAS,EAIT,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAItD,MAAM,MAAM,eAAe,GACxB,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,oBAAoB,GACpB,QAAQ,GACR,QAAQ,GACR,kBAAkB,GAClB,qBAAqB,GACrB,yBAAyB,GACzB,0BAA0B,GAC1B,KAAK,CAAC;AAET;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,iBAAiB,EAC5B,MAAM,EAAE,EAAE,EACV,MAAM,EAAE,iBAAiB,EACzB,cAAc,EAAE,SAAmB,EACnC,iBAAiB,EAAE,iBAAiB,EACpC,SAAS,UAAO,EAChB,UAAU,CAAC,EAAE,EAAE,GACb,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAyElB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC5C,SAAS,EAAE,iBAAiB,EAC5B,MAAM,EAAE,EAAE,EACV,MAAM,EAAE,iBAAiB,EACzB,cAAc,EAAE,SAAmB,EACnC,iBAAiB,EAAE,iBAAiB,EACpC,SAAS,UAAO,EAChB,UAAU,CAAC,EAAE,EAAE,GACb,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAsCd;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,EAAE,EACf,GAAG,GAAE,EAAW,EAChB,eAAe,GAAE,SAAmB,EACpC,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,SAAS,UAAO,EAChB,UAAU,CAAC,EAAE,EAAE,GACb,CAAC,iBAAiB,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CA+IjC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gCAAgC,CAC/C,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,EAAE,EACV,SAAS,EAAE,iBAAiB,EAC5B,MAAM,EAAE,iBAAiB,EACzB,iBAAiB,EAAE,iBAAiB,EACpC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,WAAW,0BAAgC,GACzC;IACF,UAAU,EAAE,EAAE,CAAC;IACf,WAAW,EAAE,EAAE,CAAC;IAChB,SAAS,EAAE,EAAE,CAAC;IACd,UAAU,EAAE,EAAE,CAAC;IACf,UAAU,EAAE,EAAE,CAAC;IACf,WAAW,EAAE,EAAE,CAAC;CAChB,CAmRA;AAED,wBAAgB,kCAAkC,CACjD,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,EAAE,EACV,SAAS,EAAE,iBAAiB,EAC5B,aAAa,EAAE,EAAE,EACjB,EAAE,EAAE,WAAW,GACb;IACF,UAAU,EAAE,EAAE,CAAC;IACf,WAAW,EAAE,EAAE,CAAC;IAChB,SAAS,EAAE,EAAE,CAAC;IACd,UAAU,EAAE,EAAE,CAAC;IACf,UAAU,EAAE,EAAE,CAAC;IACf,WAAW,EAAE,EAAE,CAAC;CAChB,CAwEA;AAED,wBAAgB,+BAA+B,CAC9C,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,CAAC,EAAE,EAAE,MAsBR"}

package/lib/node/math/trade.js

@@ -0,0 +1,503 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUser30dRollingVolumeEstimate = exports.calculateEstimatedEntryPriceWithL2 = exports.calculateEstimatedPerpEntryPrice = exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("../isomorphic/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("../constants/numericConstants");
+const market_1 = require("./market");
+const amm_1 = require("./amm");
+const utils_1 = require("./utils");
+const types_2 = require("../types");
+const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
+/**
+ * Calculates avg/max slippage (price impact) for candidate trade
+ *
+ * @deprecated use calculateEstimatedPerpEntryPrice instead
+ *
+ * @param direction
+ * @param amount
+ * @param market
+ * @param inputAssetType which asset is being traded
+ * @param useSpread whether to consider spread with calculating slippage
+ * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
+ *
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
+ *
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
+ *
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
+ *
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
+ */
+function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', mmOraclePriceData, useSpread = true, latestSlot) {
+    let oldPrice;
+    if (useSpread && market.amm.baseSpread > 0) {
+        if ((0, types_2.isVariant)(direction, 'long')) {
+            oldPrice = (0, market_1.calculateAskPrice)(market, mmOraclePriceData);
+        }
+        else {
+            oldPrice = (0, market_1.calculateBidPrice)(market, mmOraclePriceData);
+        }
+    }
+    else {
+        oldPrice = (0, market_1.calculateReservePrice)(market, mmOraclePriceData);
+    }
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
+    }
+    const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, mmOraclePriceData, useSpread);
+    const entryPrice = acquiredQuoteAssetAmount
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .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);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        amm = market.amm;
+    }
+    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
+    if (direction == types_1.PositionDirection.SHORT) {
+        (0, assert_1.assert)(newPrice.lte(oldPrice));
+    }
+    else {
+        (0, assert_1.assert)(oldPrice.lte(newPrice));
+    }
+    const pctMaxSlippage = newPrice
+        .sub(oldPrice)
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(oldPrice)
+        .abs();
+    const pctAvgSlippage = entryPrice
+        .sub(oldPrice)
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(oldPrice)
+        .abs();
+    return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice];
+}
+exports.calculateTradeSlippage = calculateTradeSlippage;
+/**
+ * Calculates acquired amounts for trade executed
+ * @param direction
+ * @param amount
+ * @param market
+ * @param inputAssetType
+ * @param useSpread
+ * @return
+ * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
+ * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
+ */
+function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', mmOraclePriceData, useSpread = true, latestSlot) {
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
+    }
+    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);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        amm = market.amm;
+    }
+    const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
+    const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
+    const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+    const acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
+}
+exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
+/**
+ * calculateTargetPriceTrade
+ * simple function for finding arbitraging trades
+ *
+ * @deprecated
+ *
+ * @param market
+ * @param targetPrice
+ * @param pct optional default is 100% gap filling, can set smaller.
+ * @param outputAssetType which asset to trade.
+ * @param useSpread whether or not to consider the spread when calculating the trade size
+ * @returns trade direction/size in order to push price to a targetPrice,
+ *
+ * [
+ *   direction => direction of trade required, PositionDirection
+ *   tradeSize => size of trade required, TODO-PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
+ * ]
+ */
+function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', mmOraclePriceData, useSpread = true, latestSlot) {
+    (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 reservePriceBefore = (0, market_1.calculateReservePrice)(market, mmOraclePriceData);
+    const bidPriceBefore = (0, market_1.calculateBidPrice)(market, mmOraclePriceData);
+    const askPriceBefore = (0, market_1.calculateAskPrice)(market, mmOraclePriceData);
+    let direction;
+    if (targetPrice.gt(reservePriceBefore)) {
+        const priceGap = targetPrice.sub(reservePriceBefore);
+        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        targetPrice = reservePriceBefore.add(priceGapScaled);
+        direction = types_1.PositionDirection.LONG;
+    }
+    else {
+        const priceGap = reservePriceBefore.sub(targetPrice);
+        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        targetPrice = reservePriceBefore.sub(priceGapScaled);
+        direction = types_1.PositionDirection.SHORT;
+    }
+    let tradeSize;
+    let baseSize;
+    let baseAssetReserveBefore;
+    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);
+        baseAssetReserveBefore = baseAssetReserve;
+        quoteAssetReserveBefore = quoteAssetReserve;
+        peg = newPeg;
+    }
+    else {
+        baseAssetReserveBefore = market.amm.baseAssetReserve;
+        quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+    }
+    const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const k = invariant.mul(numericConstants_1.PRICE_PRECISION);
+    let baseAssetReserveAfter;
+    let quoteAssetReserveAfter;
+    const biasModifier = new anchor_1.BN(1);
+    let markPriceAfter;
+    if (useSpread &&
+        targetPrice.lt(askPriceBefore) &&
+        targetPrice.gt(bidPriceBefore)) {
+        // no trade, market is at target
+        if (reservePriceBefore.gt(targetPrice)) {
+            direction = types_1.PositionDirection.SHORT;
+        }
+        else {
+            direction = types_1.PositionDirection.LONG;
+        }
+        tradeSize = numericConstants_1.ZERO;
+        return [direction, tradeSize, targetPrice, 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);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        direction = types_1.PositionDirection.SHORT;
+        tradeSize = quoteAssetReserveBefore
+            .sub(quoteAssetReserveAfter)
+            .mul(peg)
+            .div(numericConstants_1.PEG_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+        baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
+    }
+    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);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        direction = types_1.PositionDirection.LONG;
+        tradeSize = quoteAssetReserveAfter
+            .sub(quoteAssetReserveBefore)
+            .mul(peg)
+            .div(numericConstants_1.PEG_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+        baseSize = baseAssetReserveBefore.sub(baseAssetReserveAfter);
+    }
+    else {
+        // no trade, market is at target
+        direction = types_1.PositionDirection.LONG;
+        tradeSize = numericConstants_1.ZERO;
+        return [direction, tradeSize, targetPrice, targetPrice];
+    }
+    let tp1 = targetPrice;
+    let tp2 = markPriceAfter;
+    let originalDiff = targetPrice.sub(reservePriceBefore);
+    if (direction == types_1.PositionDirection.SHORT) {
+        tp1 = markPriceAfter;
+        tp2 = targetPrice;
+        originalDiff = reservePriceBefore.sub(targetPrice);
+    }
+    const entryPrice = tradeSize
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(baseSize.abs());
+    (0, assert_1.assert)(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
+    (0, assert_1.assert)(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
+        tp2.toString() +
+        '>=' +
+        tp1.toString() +
+        'err: ' +
+        tp2.sub(tp1).abs().toString());
+    if (outputAssetType == 'quote') {
+        return [direction, tradeSize, entryPrice, targetPrice];
+    }
+    else {
+        return [direction, baseSize, entryPrice, targetPrice];
+    }
+}
+exports.calculateTargetPriceTrade = calculateTargetPriceTrade;
+/**
+ * Calculates the estimated entry price and price impact of order, in base or quote
+ * Price impact is based on the difference between the entry price and the best bid/ask price (whether it's dlob or vamm)
+ *
+ * @param assetType
+ * @param amount
+ * @param direction
+ * @param market
+ * @param oraclePriceData
+ * @param dlob
+ * @param slot
+ * @param usersToSkip
+ */
+function calculateEstimatedPerpEntryPrice(assetType, amount, direction, market, mmOraclePriceData, dlob, slot, usersToSkip = new Map()) {
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return {
+            entryPrice: numericConstants_1.ZERO,
+            priceImpact: numericConstants_1.ZERO,
+            bestPrice: numericConstants_1.ZERO,
+            worstPrice: numericConstants_1.ZERO,
+            baseFilled: numericConstants_1.ZERO,
+            quoteFilled: numericConstants_1.ZERO,
+        };
+    }
+    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 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);
+    let ammLiquidity;
+    if (assetType === 'base') {
+        ammLiquidity = takerIsLong ? ammAsks.abs() : ammBids;
+    }
+    else {
+        const [afterSwapQuoteReserves, _] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'base', takerIsLong ? ammAsks.abs() : ammBids, (0, amm_1.getSwapDirection)('base', direction));
+        ammLiquidity = (0, amm_1.calculateQuoteAssetAmountSwapped)(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
+    }
+    const invariant = amm.sqrtK.mul(amm.sqrtK);
+    let bestPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    let cumulativeBaseFilled = numericConstants_1.ZERO;
+    let cumulativeQuoteFilled = numericConstants_1.ZERO;
+    let limitOrder = limitOrders.next().value;
+    if (limitOrder) {
+        const limitOrderPrice = limitOrder.getPrice(mmOraclePriceData, slot);
+        bestPrice = takerIsLong
+            ? anchor_1.BN.min(limitOrderPrice, bestPrice)
+            : anchor_1.BN.max(limitOrderPrice, bestPrice);
+    }
+    let worstPrice = bestPrice;
+    if (assetType === 'base') {
+        while (!cumulativeBaseFilled.eq(amount) &&
+            (ammLiquidity.gt(numericConstants_1.ZERO) || limitOrder)) {
+            const limitOrderPrice = limitOrder === null || limitOrder === void 0 ? void 0 : limitOrder.getPrice(mmOraclePriceData, slot);
+            let maxAmmFill;
+            if (limitOrderPrice) {
+                const newBaseReserves = (0, utils_1.squareRootBN)(invariant
+                    .mul(numericConstants_1.PRICE_PRECISION)
+                    .mul(amm.pegMultiplier)
+                    .div(limitOrderPrice)
+                    .div(numericConstants_1.PEG_PRECISION));
+                // will be zero if the limit order price is better than the amm price
+                maxAmmFill = takerIsLong
+                    ? amm.baseAssetReserve.sub(newBaseReserves)
+                    : newBaseReserves.sub(amm.baseAssetReserve);
+            }
+            else {
+                maxAmmFill = amount.sub(cumulativeBaseFilled);
+            }
+            maxAmmFill = anchor_1.BN.min(maxAmmFill, ammLiquidity);
+            if (maxAmmFill.gt(numericConstants_1.ZERO)) {
+                const baseFilled = anchor_1.BN.min(amount.sub(cumulativeBaseFilled), maxAmmFill);
+                const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'base', baseFilled, swapDirection);
+                ammLiquidity = ammLiquidity.sub(baseFilled);
+                const quoteFilled = (0, amm_1.calculateQuoteAssetAmountSwapped)(amm.quoteAssetReserve.sub(afterSwapQuoteReserves).abs(), amm.pegMultiplier, swapDirection);
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                amm.baseAssetReserve = afterSwapBaseReserves;
+                amm.quoteAssetReserve = afterSwapQuoteReserves;
+                worstPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+                if (cumulativeBaseFilled.eq(amount)) {
+                    break;
+                }
+            }
+            if (!limitOrder) {
+                continue;
+            }
+            if (usersToSkip.has(limitOrder.userAccount)) {
+                continue;
+            }
+            const baseFilled = anchor_1.BN.min(limitOrder.order.baseAssetAmount.sub(limitOrder.order.baseAssetAmountFilled), amount.sub(cumulativeBaseFilled));
+            const quoteFilled = baseFilled.mul(limitOrderPrice).div(numericConstants_1.BASE_PRECISION);
+            cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+            cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            worstPrice = limitOrderPrice;
+            if (cumulativeBaseFilled.eq(amount)) {
+                break;
+            }
+            limitOrder = limitOrders.next().value;
+        }
+    }
+    else {
+        while (!cumulativeQuoteFilled.eq(amount) &&
+            (ammLiquidity.gt(numericConstants_1.ZERO) || limitOrder)) {
+            const limitOrderPrice = limitOrder === null || limitOrder === void 0 ? void 0 : limitOrder.getPrice(mmOraclePriceData, slot);
+            let maxAmmFill;
+            if (limitOrderPrice) {
+                const newQuoteReserves = (0, utils_1.squareRootBN)(invariant
+                    .mul(numericConstants_1.PEG_PRECISION)
+                    .mul(limitOrderPrice)
+                    .div(amm.pegMultiplier)
+                    .div(numericConstants_1.PRICE_PRECISION));
+                // will be zero if the limit order price is better than the amm price
+                maxAmmFill = takerIsLong
+                    ? newQuoteReserves.sub(amm.quoteAssetReserve)
+                    : amm.quoteAssetReserve.sub(newQuoteReserves);
+            }
+            else {
+                maxAmmFill = amount.sub(cumulativeQuoteFilled);
+            }
+            maxAmmFill = anchor_1.BN.min(maxAmmFill, ammLiquidity);
+            if (maxAmmFill.gt(numericConstants_1.ZERO)) {
+                const quoteFilled = anchor_1.BN.min(amount.sub(cumulativeQuoteFilled), maxAmmFill);
+                const [afterSwapQuoteReserves, afterSwapBaseReserves] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, 'quote', quoteFilled, swapDirection);
+                ammLiquidity = ammLiquidity.sub(quoteFilled);
+                const baseFilled = afterSwapBaseReserves
+                    .sub(amm.baseAssetReserve)
+                    .abs();
+                cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+                cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+                amm.baseAssetReserve = afterSwapBaseReserves;
+                amm.quoteAssetReserve = afterSwapQuoteReserves;
+                worstPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+                if (cumulativeQuoteFilled.eq(amount)) {
+                    break;
+                }
+            }
+            if (!limitOrder) {
+                continue;
+            }
+            if (usersToSkip.has(limitOrder.userAccount)) {
+                continue;
+            }
+            const quoteFilled = anchor_1.BN.min(limitOrder.order.baseAssetAmount
+                .sub(limitOrder.order.baseAssetAmountFilled)
+                .mul(limitOrderPrice)
+                .div(numericConstants_1.BASE_PRECISION), amount.sub(cumulativeQuoteFilled));
+            const baseFilled = quoteFilled.mul(numericConstants_1.BASE_PRECISION).div(limitOrderPrice);
+            cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+            cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            worstPrice = limitOrderPrice;
+            if (cumulativeQuoteFilled.eq(amount)) {
+                break;
+            }
+            limitOrder = limitOrders.next().value;
+        }
+    }
+    const entryPrice = cumulativeBaseFilled && cumulativeBaseFilled.gt(numericConstants_1.ZERO)
+        ? cumulativeQuoteFilled.mul(numericConstants_1.BASE_PRECISION).div(cumulativeBaseFilled)
+        : numericConstants_1.ZERO;
+    const priceImpact = bestPrice && bestPrice.gt(numericConstants_1.ZERO)
+        ? entryPrice.sub(bestPrice).mul(numericConstants_1.PRICE_PRECISION).div(bestPrice).abs()
+        : numericConstants_1.ZERO;
+    return {
+        entryPrice,
+        priceImpact,
+        bestPrice,
+        worstPrice,
+        baseFilled: cumulativeBaseFilled,
+        quoteFilled: cumulativeQuoteFilled,
+    };
+}
+exports.calculateEstimatedPerpEntryPrice = calculateEstimatedPerpEntryPrice;
+function calculateEstimatedEntryPriceWithL2(assetType, amount, direction, basePrecision, l2) {
+    const takerIsLong = (0, types_2.isVariant)(direction, 'long');
+    let cumulativeBaseFilled = numericConstants_1.ZERO;
+    let cumulativeQuoteFilled = numericConstants_1.ZERO;
+    const levels = [...(takerIsLong ? l2.asks : l2.bids)];
+    let nextLevel = levels.shift();
+    let bestPrice;
+    let worstPrice;
+    if (nextLevel) {
+        bestPrice = nextLevel.price;
+        worstPrice = nextLevel.price;
+    }
+    else {
+        bestPrice = takerIsLong ? numericConstants_1.BN_MAX : numericConstants_1.ZERO;
+        worstPrice = bestPrice;
+    }
+    if (assetType === 'base') {
+        while (!cumulativeBaseFilled.eq(amount) && nextLevel) {
+            const price = nextLevel.price;
+            const size = nextLevel.size;
+            worstPrice = price;
+            const baseFilled = anchor_1.BN.min(size, amount.sub(cumulativeBaseFilled));
+            const quoteFilled = baseFilled.mul(price).div(basePrecision);
+            cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+            cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            nextLevel = levels.shift();
+        }
+    }
+    else {
+        while (!cumulativeQuoteFilled.eq(amount) && nextLevel) {
+            const price = nextLevel.price;
+            const size = nextLevel.size;
+            worstPrice = price;
+            const quoteFilled = anchor_1.BN.min(size.mul(price).div(basePrecision), amount.sub(cumulativeQuoteFilled));
+            const baseFilled = quoteFilled.mul(basePrecision).div(price);
+            cumulativeBaseFilled = cumulativeBaseFilled.add(baseFilled);
+            cumulativeQuoteFilled = cumulativeQuoteFilled.add(quoteFilled);
+            nextLevel = levels.shift();
+        }
+    }
+    const entryPrice = cumulativeBaseFilled && cumulativeBaseFilled.gt(numericConstants_1.ZERO)
+        ? cumulativeQuoteFilled.mul(basePrecision).div(cumulativeBaseFilled)
+        : numericConstants_1.ZERO;
+    const priceImpact = bestPrice && bestPrice.gt(numericConstants_1.ZERO)
+        ? entryPrice.sub(bestPrice).mul(numericConstants_1.PRICE_PRECISION).div(bestPrice).abs()
+        : numericConstants_1.ZERO;
+    return {
+        entryPrice,
+        priceImpact,
+        bestPrice,
+        worstPrice,
+        baseFilled: cumulativeBaseFilled,
+        quoteFilled: cumulativeQuoteFilled,
+    };
+}
+exports.calculateEstimatedEntryPriceWithL2 = calculateEstimatedEntryPriceWithL2;
+function getUser30dRollingVolumeEstimate(userStatsAccount, now) {
+    now = now || new anchor_1.BN(new Date().getTime() / 1000);
+    const sinceLastTaker = anchor_1.BN.max(now.sub(userStatsAccount.lastTakerVolume30DTs), numericConstants_1.ZERO);
+    const sinceLastMaker = anchor_1.BN.max(now.sub(userStatsAccount.lastMakerVolume30DTs), numericConstants_1.ZERO);
+    const thirtyDaysInSeconds = new anchor_1.BN(60 * 60 * 24 * 30);
+    const last30dVolume = userStatsAccount.takerVolume30D
+        .mul(anchor_1.BN.max(thirtyDaysInSeconds.sub(sinceLastTaker), numericConstants_1.ZERO))
+        .div(thirtyDaysInSeconds)
+        .add(userStatsAccount.makerVolume30D
+        .mul(anchor_1.BN.max(thirtyDaysInSeconds.sub(sinceLastMaker), numericConstants_1.ZERO))
+        .div(thirtyDaysInSeconds));
+    return last30dVolume;
+}
+exports.getUser30dRollingVolumeEstimate = getUser30dRollingVolumeEstimate;

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

@@ -0,0 +1,24 @@
+/// <reference types="bn.js" />
+import { BN } from '../isomorphic/anchor';
+export declare function clampBN(x: BN, min: BN, max: BN): BN;
+export declare const squareRootBN: (n: BN) => BN;
+export declare const divCeil: (a: BN, b: BN) => BN;
+export declare const sigNum: (x: BN) => BN;
+/**
+ * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
+ * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates
+ * @param now: current blockchain unix timestamp
+ * @param lastUpdateTs: the unix timestamp of the last update
+ * @param updatePeriod: desired interval between updates (in seconds)
+ * @returns: timeRemainingUntilUpdate (in seconds)
+ */
+export declare function timeRemainingUntilUpdate(now: BN, lastUpdateTs: BN, updatePeriod: BN): BN;
+export declare const checkSameDate: (dateString1: string, dateString2: string) => boolean;
+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)
+ */
+export declare function numberToSafeBN(number: number, precision: BN): BN;
+//# sourceMappingURL=utils.d.ts.map

package/lib/node/math/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/math/utils.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAG1C,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,CAEnD;AAED,eAAO,MAAM,YAAY,MAAO,EAAE,KAAG,EAgBpC,CAAC;AAEF,eAAO,MAAM,OAAO,MAAO,EAAE,KAAK,EAAE,KAAG,EAUtC,CAAC;AAEF,eAAO,MAAM,MAAM,MAAO,EAAE,KAAG,EAE9B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACvC,GAAG,EAAE,EAAE,EACP,YAAY,EAAE,EAAE,EAChB,YAAY,EAAE,EAAE,GACd,EAAE,CAgCJ;AAED,eAAO,MAAM,aAAa,gBAAiB,MAAM,eAAe,MAAM,YAUrE,CAAC;AAEF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,CAYhE"}