@drift-labs/sdk 2.52.0-beta.1 → 2.52.0-beta.10

package/lib/math/amm.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateVolSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateInventoryScale = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
+exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateVolSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateReferencePriceOffset = exports.calculateInventoryScale = exports.calculateInventoryLiquidityRatio = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
@@ -201,11 +201,7 @@ function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBas
     return [openBids, openAsks];
 }
 exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
-function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, directionalSpread, maxSpread) {
-    if (baseAssetAmountWithAmm.eq(numericConstants_1.ZERO)) {
-        return 1;
-    }
-    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
+function calculateInventoryLiquidityRatio(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
     // inventory skew
     const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
     const minSideLiquidity = anchor_1.BN.min(openBids.abs(), openAsks.abs());
@@ -213,6 +209,15 @@ function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBa
         .mul(numericConstants_1.PERCENTAGE_PRECISION)
         .div(anchor_1.BN.max(minSideLiquidity, numericConstants_1.ONE))
         .abs(), numericConstants_1.PERCENTAGE_PRECISION);
+    return inventoryScaleBN;
+}
+exports.calculateInventoryLiquidityRatio = calculateInventoryLiquidityRatio;
+function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, directionalSpread, maxSpread) {
+    if (baseAssetAmountWithAmm.eq(numericConstants_1.ZERO)) {
+        return 1;
+    }
+    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
+    const inventoryScaleBN = calculateInventoryLiquidityRatio(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
     const inventoryScaleMaxBN = anchor_1.BN.max(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, new anchor_1.BN(maxSpread)
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(new anchor_1.BN(Math.max(directionalSpread, 1))));
@@ -220,6 +225,36 @@ function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBa
     return inventoryScaleCapped;
 }
 exports.calculateInventoryScale = calculateInventoryScale;
+function calculateReferencePriceOffset(reservePrice, last24hAvgFundingRate, liquidityFraction, oracleTwapFast, markTwapFast, oracleTwapSlow, markTwapSlow, maxOffsetPct) {
+    if (last24hAvgFundingRate.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const maxOffsetInPrice = new anchor_1.BN(maxOffsetPct)
+        .mul(reservePrice)
+        .div(numericConstants_1.PERCENTAGE_PRECISION);
+    // Calculate quote denominated market premium
+    const markPremiumMinute = (0, __1.clampBN)(markTwapFast.sub(oracleTwapFast), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    const markPremiumHour = (0, __1.clampBN)(markTwapSlow.sub(oracleTwapSlow), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    // Convert last24hAvgFundingRate to quote denominated premium
+    const markPremiumDay = (0, __1.clampBN)(last24hAvgFundingRate.div(numericConstants_1.FUNDING_RATE_BUFFER_PRECISION).mul(new anchor_1.BN(24)), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    // Take average clamped premium as the price-based offset
+    const markPremiumAvg = markPremiumMinute
+        .add(markPremiumHour)
+        .add(markPremiumDay)
+        .div(new anchor_1.BN(3));
+    const markPremiumAvgPct = markPremiumAvg
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .div(reservePrice);
+    const inventoryPct = (0, __1.clampBN)(liquidityFraction.mul(new anchor_1.BN(maxOffsetPct)).div(numericConstants_1.PERCENTAGE_PRECISION), maxOffsetInPrice.mul(new anchor_1.BN(-1)), maxOffsetInPrice);
+    // Only apply when inventory is consistent with recent and 24h market premium
+    let offsetPct = markPremiumAvgPct.add(inventoryPct);
+    if (!(0, __1.sigNum)(inventoryPct).eq((0, __1.sigNum)(markPremiumAvgPct))) {
+        offsetPct = numericConstants_1.ZERO;
+    }
+    const clampedOffsetPct = (0, __1.clampBN)(offsetPct, new anchor_1.BN(-maxOffsetPct), new anchor_1.BN(maxOffsetPct));
+    return clampedOffsetPct;
+}
+exports.calculateReferencePriceOffset = calculateReferencePriceOffset;
 function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions) {
     // vAMM skew
     const netBaseAssetValue = quoteAssetReserve
@@ -283,6 +318,8 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
         halfRevenueRetreatAmount: 0,
         longSpreadwRevRetreat: 0,
         shortSpreadwRevRetreat: 0,
+        longSpreadwOffsetShrink: 0,
+        shortSpreadwOffsetShrink: 0,
         totalSpread: 0,
         longSpread: 0,
         shortSpread: 0,
@@ -380,11 +417,13 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
     return [longSpread, shortSpread];
 }
 exports.calculateSpreadBN = calculateSpreadBN;
-function calculateSpread(amm, oraclePriceData, now) {
+function calculateSpread(amm, oraclePriceData, now, reservePrice) {
     if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
         return [amm.baseSpread / 2, amm.baseSpread / 2];
     }
-    const reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    if (!reservePrice) {
+        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 = reservePrice
@@ -410,10 +449,15 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
                 quoteAssetReserve: amm.quoteAssetReserve,
             };
         }
-        const spreadFraction = anchor_1.BN.max(new anchor_1.BN(spread / 2), numericConstants_1.ONE);
+        let spreadFraction = new anchor_1.BN(spread / 2);
+        // make non-zero
+        if (spreadFraction.eq(numericConstants_1.ZERO)) {
+            spreadFraction = spread >= 0 ? new anchor_1.BN(1) : new anchor_1.BN(-1);
+        }
         const quoteAssetReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(spreadFraction));
         let quoteAssetReserve;
-        if ((0, types_1.isVariant)(direction, 'long')) {
+        if ((spread >= 0 && (0, types_1.isVariant)(direction, 'long')) ||
+            (spread <= 0 && (0, types_1.isVariant)(direction, 'short'))) {
             quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
         }
         else {
@@ -425,9 +469,14 @@ function calculateSpreadReserves(amm, oraclePriceData, now) {
             quoteAssetReserve,
         };
     }
-    const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData, now);
-    const askReserves = calculateSpreadReserve(longSpread, types_1.PositionDirection.LONG, amm);
-    const bidReserves = calculateSpreadReserve(shortSpread, types_1.PositionDirection.SHORT, amm);
+    const reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
+    // always allow 10 bps of price offset, up to a fifth of the market's max_spread
+    const maxOffset = Math.max(amm.maxSpread / 5, numericConstants_1.PERCENTAGE_PRECISION.toNumber() / 1000);
+    const liquidityFraction = calculateInventoryLiquidityRatio(amm.baseAssetAmountWithAmm, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
+    const referencePriceOffset = calculateReferencePriceOffset(reservePrice, amm.last24HAvgFundingRate, liquidityFraction, amm.historicalOracleData.lastOraclePriceTwap5Min, amm.lastMarkPriceTwap5Min, amm.historicalOracleData.lastOraclePriceTwap, amm.lastMarkPriceTwap, maxOffset);
+    const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData, now, reservePrice);
+    const askReserves = calculateSpreadReserve(longSpread + referencePriceOffset.toNumber(), types_1.PositionDirection.LONG, amm);
+    const bidReserves = calculateSpreadReserve(shortSpread + referencePriceOffset.toNumber(), types_1.PositionDirection.SHORT, amm);
     return [bidReserves, askReserves];
 }
 exports.calculateSpreadReserves = calculateSpreadReserves;

package/lib/math/state.js

@@ -22,6 +22,9 @@ function calculateInitUserFee(stateAccount) {
 }
 exports.calculateInitUserFee = calculateInitUserFee;
 function getMaxNumberOfSubAccounts(stateAccount) {
+    if (stateAccount.maxNumberOfSubAccounts <= 5) {
+        return new __1.BN(stateAccount.maxNumberOfSubAccounts);
+    }
     return new __1.BN(stateAccount.maxNumberOfSubAccounts).muln(100);
 }
 exports.getMaxNumberOfSubAccounts = getMaxNumberOfSubAccounts;

package/lib/orderSubscriber/OrderSubscriber.js

@@ -28,6 +28,7 @@ class OrderSubscriber {
                 commitment: this.commitment,
                 skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
                 resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+                resyncIntervalMs: config.subscriptionConfig.resyncIntervalMs,
             });
         }
         if ((_a = config.fastDecode) !== null && _a !== void 0 ? _a : true) {

package/lib/orderSubscriber/WebsocketSubscription.d.ts

@@ -5,12 +5,15 @@ export declare class WebsocketSubscription {
     private commitment;
     private skipInitialLoad;
     private resubTimeoutMs?;
+    private resyncIntervalMs?;
     private subscriber?;
-    constructor({ orderSubscriber, commitment, skipInitialLoad, resubTimeoutMs, }: {
+    private resyncTimeoutId?;
+    constructor({ orderSubscriber, commitment, skipInitialLoad, resubTimeoutMs, resyncIntervalMs, }: {
         orderSubscriber: OrderSubscriber;
         commitment: Commitment;
         skipInitialLoad?: boolean;
         resubTimeoutMs?: number;
+        resyncIntervalMs?: number;
     });
     subscribe(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/orderSubscriber/WebsocketSubscription.js

@@ -4,11 +4,12 @@ exports.WebsocketSubscription = void 0;
 const memcmp_1 = require("../memcmp");
 const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
 class WebsocketSubscription {
-    constructor({ orderSubscriber, commitment, skipInitialLoad = false, resubTimeoutMs, }) {
+    constructor({ orderSubscriber, commitment, skipInitialLoad = false, resubTimeoutMs, resyncIntervalMs, }) {
         this.orderSubscriber = orderSubscriber;
         this.commitment = commitment;
         this.skipInitialLoad = skipInitialLoad;
         this.resubTimeoutMs = resubTimeoutMs;
+        this.resyncIntervalMs = resyncIntervalMs;
     }
     async subscribe() {
         if (this.subscriber) {
@@ -25,12 +26,35 @@ class WebsocketSubscription {
         if (!this.skipInitialLoad) {
             await this.orderSubscriber.fetch();
         }
+        if (this.resyncIntervalMs) {
+            const recursiveResync = () => {
+                this.resyncTimeoutId = setTimeout(() => {
+                    this.orderSubscriber
+                        .fetch()
+                        .catch((e) => {
+                        console.error('Failed to resync in OrderSubscriber');
+                        console.log(e);
+                    })
+                        .finally(() => {
+                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        if (!this.resyncTimeoutId)
+                            return;
+                        recursiveResync();
+                    });
+                }, this.resyncIntervalMs);
+            };
+            recursiveResync();
+        }
     }
     async unsubscribe() {
         if (!this.subscriber)
             return;
         await this.subscriber.unsubscribe();
         this.subscriber = undefined;
+        if (this.resyncTimeoutId !== undefined) {
+            clearTimeout(this.resyncTimeoutId);
+            this.resyncTimeoutId = undefined;
+        }
     }
 }
 exports.WebsocketSubscription = WebsocketSubscription;

package/lib/orderSubscriber/types.d.ts

@@ -11,6 +11,7 @@ export type OrderSubscriberConfig = {
         type: 'websocket';
         skipInitialLoad?: boolean;
         resubTimeoutMs?: number;
+        resyncIntervalMs?: number;
         commitment?: Commitment;
     };
     fastDecode?: boolean;

package/lib/phoenix/phoenixSubscriber.js

@@ -99,14 +99,18 @@ class PhoenixSubscriber {
         return this.getL2Levels('asks');
     }
     *getL2Levels(side) {
-        const basePrecision = Math.pow(10, this.market.data.header.baseParams.decimals);
-        const pricePrecision = numericConstants_1.PRICE_PRECISION.toNumber();
-        const ladder = (0, phoenix_sdk_1.getMarketUiLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 20);
+        const tickSize = this.market.data.header
+            .tickSizeInQuoteAtomsPerBaseUnit;
+        const baseLotsToRawBaseUnits = this.market.baseLotsToRawBaseUnits(1);
+        const basePrecision = new anchor_1.BN(Math.pow(10, this.market.data.header.baseParams.decimals) *
+            baseLotsToRawBaseUnits);
+        const pricePrecision = numericConstants_1.PRICE_PRECISION.div(tickSize);
+        const ladder = (0, phoenix_sdk_1.getMarketLadder)(this.market, this.lastSlot, this.lastUnixTimestamp, 20);
         for (let i = 0; i < ladder[side].length; i++) {
-            const { price, quantity } = ladder[side][i];
-            const size = new anchor_1.BN(Math.floor(quantity * basePrecision));
+            const { priceInTicks, sizeInBaseLots } = ladder[side][i];
+            const size = sizeInBaseLots.mul(basePrecision);
             yield {
-                price: new anchor_1.BN(Math.floor(price * pricePrecision)),
+                price: priceInTicks.mul(new anchor_1.BN(pricePrecision)),
                 size,
                 sources: {
                     phoenix: size,

package/lib/priorityFee/averageOverSlotsStrategy.d.ts

@@ -0,0 +1,12 @@
+import { PriorityFeeStrategy } from './types';
+export declare class AverageOverSlotsStrategy implements PriorityFeeStrategy {
+    private lookbackSlots;
+    /**
+     * @param lookbackSlots The number of slots to look back from the max slot in the sample
+     */
+    constructor(lookbackSlots?: number);
+    calculate(samples: {
+        slot: number;
+        prioritizationFee: number;
+    }[]): number;
+}

package/lib/priorityFee/averageOverSlotsStrategy.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AverageOverSlotsStrategy = void 0;
+class AverageOverSlotsStrategy {
+    /**
+     * @param lookbackSlots The number of slots to look back from the max slot in the sample
+     */
+    constructor(lookbackSlots = 10) {
+        this.lookbackSlots = lookbackSlots;
+    }
+    calculate(samples) {
+        if (samples.length === 0) {
+            return 0;
+        }
+        const stopSlot = samples[0].slot - this.lookbackSlots;
+        let runningSumFees = 0;
+        let countFees = 0;
+        for (let i = 0; i < samples.length; i++) {
+            if (samples[i].slot <= stopSlot) {
+                return runningSumFees / countFees;
+            }
+            runningSumFees += samples[i].prioritizationFee;
+            countFees++;
+        }
+        return runningSumFees / countFees;
+    }
+}
+exports.AverageOverSlotsStrategy = AverageOverSlotsStrategy;

package/lib/priorityFee/averageStrategy.d.ts

@@ -0,0 +1,7 @@
+import { PriorityFeeStrategy } from './types';
+export declare class AverageStrategy implements PriorityFeeStrategy {
+    calculate(samples: {
+        slot: number;
+        prioritizationFee: number;
+    }[]): number;
+}

package/lib/priorityFee/averageStrategy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AverageStrategy = void 0;
+class AverageStrategy {
+    calculate(samples) {
+        return (samples.reduce((a, b) => {
+            return a + b.prioritizationFee;
+        }, 0) / samples.length);
+    }
+}
+exports.AverageStrategy = AverageStrategy;

package/lib/priorityFee/ewmaStrategy.d.ts

@@ -0,0 +1,13 @@
+import { PriorityFeeStrategy } from './types';
+declare class EwmaStrategy implements PriorityFeeStrategy {
+    private halfLife;
+    /**
+     * @param halfLife The half life of the EWMA in slots. Default is 25 slots, approx 10 seconds.
+     */
+    constructor(halfLife?: number);
+    calculate(samples: {
+        slot: number;
+        prioritizationFee: number;
+    }[]): number;
+}
+export { EwmaStrategy };

package/lib/priorityFee/ewmaStrategy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EwmaStrategy = void 0;
+class EwmaStrategy {
+    /**
+     * @param halfLife The half life of the EWMA in slots. Default is 25 slots, approx 10 seconds.
+     */
+    constructor(halfLife = 25) {
+        this.halfLife = halfLife;
+    }
+    // samples provided in desc slot order
+    calculate(samples) {
+        if (samples.length === 0) {
+            return 0;
+        }
+        if (samples.length === 1) {
+            return samples[0].prioritizationFee;
+        }
+        let ewma = 0;
+        const samplesReversed = samples.slice().reverse();
+        for (let i = 0; i < samplesReversed.length; i++) {
+            if (i === 0) {
+                ewma = samplesReversed[i].prioritizationFee;
+                continue;
+            }
+            const gap = samplesReversed[i].slot - samplesReversed[i - 1].slot;
+            const alpha = 1 - Math.exp((Math.log(0.5) / this.halfLife) * gap);
+            ewma = alpha * samplesReversed[i].prioritizationFee + (1 - alpha) * ewma;
+        }
+        return ewma;
+    }
+}
+exports.EwmaStrategy = EwmaStrategy;

package/lib/priorityFee/index.d.ts

@@ -0,0 +1,7 @@
+export * from './averageOverSlotsStrategy';
+export * from './averageStrategy';
+export * from './ewmaStrategy';
+export * from './maxOverSlotsStrategy';
+export * from './maxStrategy';
+export * from './priorityFeeSubscriber';
+export * from './types';

package/lib/priorityFee/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./averageOverSlotsStrategy"), exports);
+__exportStar(require("./averageStrategy"), exports);
+__exportStar(require("./ewmaStrategy"), exports);
+__exportStar(require("./maxOverSlotsStrategy"), exports);
+__exportStar(require("./maxStrategy"), exports);
+__exportStar(require("./priorityFeeSubscriber"), exports);
+__exportStar(require("./types"), exports);

package/lib/priorityFee/maxOverSlotsStrategy.d.ts

@@ -0,0 +1,12 @@
+import { PriorityFeeStrategy } from './types';
+export declare class MaxOverSlotsStrategy implements PriorityFeeStrategy {
+    private lookbackSlots;
+    /**
+     * @param lookbackSlots The number of slots to look back from the max slot in the sample
+     */
+    constructor(lookbackSlots?: number);
+    calculate(samples: {
+        slot: number;
+        prioritizationFee: number;
+    }[]): number;
+}

package/lib/priorityFee/maxOverSlotsStrategy.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxOverSlotsStrategy = void 0;
+class MaxOverSlotsStrategy {
+    /**
+     * @param lookbackSlots The number of slots to look back from the max slot in the sample
+     */
+    constructor(lookbackSlots = 10) {
+        this.lookbackSlots = lookbackSlots;
+    }
+    calculate(samples) {
+        if (samples.length === 0) {
+            return 0;
+        }
+        // Assuming samples are sorted in descending order of slot.
+        const stopSlot = samples[0].slot - this.lookbackSlots;
+        let currMaxFee = samples[0].prioritizationFee;
+        for (let i = 0; i < samples.length; i++) {
+            if (samples[i].slot <= stopSlot) {
+                return currMaxFee;
+            }
+            if (samples[i].prioritizationFee > currMaxFee) {
+                currMaxFee = samples[i].prioritizationFee;
+            }
+        }
+        return currMaxFee;
+    }
+}
+exports.MaxOverSlotsStrategy = MaxOverSlotsStrategy;

package/lib/priorityFee/maxStrategy.d.ts

@@ -0,0 +1,7 @@
+import { PriorityFeeStrategy } from './types';
+export declare class MaxStrategy implements PriorityFeeStrategy {
+    calculate(samples: {
+        slot: number;
+        prioritizationFee: number;
+    }[]): number;
+}

package/lib/priorityFee/maxStrategy.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxStrategy = void 0;
+class MaxStrategy {
+    calculate(samples) {
+        return Math.max(...samples.map((result) => result.prioritizationFee));
+    }
+}
+exports.MaxStrategy = MaxStrategy;

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -1,20 +1,31 @@
 import { Connection, PublicKey } from '@solana/web3.js';
+import { PriorityFeeStrategy } from './types';
+import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
+import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
 export declare class PriorityFeeSubscriber {
     connection: Connection;
     frequencyMs: number;
     addresses: PublicKey[];
-    slotsToCheck: number;
+    customStrategy?: PriorityFeeStrategy;
+    averageStrategy: AverageOverSlotsStrategy;
+    maxStrategy: MaxOverSlotsStrategy;
     intervalId?: ReturnType<typeof setTimeout>;
     latestPriorityFee: number;
-    avgPriorityFee: number;
-    maxPriorityFee: number;
+    lastStrategyResult: number;
+    lastCustomStrategyResult: number;
+    lastAvgStrategyResult: number;
+    lastMaxStrategyResult: number;
     lastSlotSeen: number;
-    constructor({ connection, frequencyMs, addresses, slotsToCheck, }: {
+    constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck, }: {
         connection: Connection;
         frequencyMs: number;
         addresses: PublicKey[];
+        customStrategy?: PriorityFeeStrategy;
         slotsToCheck?: number;
     });
+    get avgPriorityFee(): number;
+    get maxPriorityFee(): number;
+    get customPriorityFee(): number;
     subscribe(): Promise<void>;
     load(): Promise<void>;
     unsubscribe(): Promise<void>;

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -1,18 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityFeeSubscriber = void 0;
+const averageOverSlotsStrategy_1 = require("./averageOverSlotsStrategy");
+const maxOverSlotsStrategy_1 = require("./maxOverSlotsStrategy");
 class PriorityFeeSubscriber {
-    constructor({ connection, frequencyMs, addresses, slotsToCheck = 10, }) {
+    constructor({ connection, frequencyMs, addresses, customStrategy, slotsToCheck = 10, }) {
+        this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy();
+        this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy();
         this.latestPriorityFee = 0;
-        // avg of last {slotsToCheck} slots
-        this.avgPriorityFee = 0;
-        // max of last {slotsToCheck} slots
-        this.maxPriorityFee = 0;
+        this.lastStrategyResult = 0;
+        this.lastCustomStrategyResult = 0;
+        this.lastAvgStrategyResult = 0;
+        this.lastMaxStrategyResult = 0;
         this.lastSlotSeen = 0;
         this.connection = connection;
         this.frequencyMs = frequencyMs;
         this.addresses = addresses;
-        this.slotsToCheck = slotsToCheck;
+        if (slotsToCheck) {
+            this.averageStrategy = new averageOverSlotsStrategy_1.AverageOverSlotsStrategy(slotsToCheck);
+            this.maxStrategy = new maxOverSlotsStrategy_1.MaxOverSlotsStrategy(slotsToCheck);
+        }
+        if (customStrategy) {
+            this.customStrategy = customStrategy;
+        }
+    }
+    get avgPriorityFee() {
+        return this.lastAvgStrategyResult;
+    }
+    get maxPriorityFee() {
+        return this.lastMaxStrategyResult;
+    }
+    get customPriorityFee() {
+        if (!this.customStrategy) {
+            console.error('Custom strategy not set');
+        }
+        return this.lastCustomStrategyResult;
     }
     async subscribe() {
         if (this.intervalId) {
@@ -21,20 +43,22 @@ class PriorityFeeSubscriber {
         this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
     }
     async load() {
-        var _a, _b, _c;
         // @ts-ignore
         const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
-        const descResults = (_c = (_b = (_a = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result) === null || _a === void 0 ? void 0 : _a.sort((a, b) => b.slot - a.slot)) === null || _b === void 0 ? void 0 : _b.slice(0, this.slotsToCheck)) !== null && _c !== void 0 ? _c : [];
-        if (!(descResults === null || descResults === void 0 ? void 0 : descResults.length))
+        // getRecentPrioritizationFees returns results unsorted
+        const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
+        if (!results.length)
             return;
+        const descResults = results.sort((a, b) => b.slot - a.slot);
         const mostRecentResult = descResults[0];
         this.latestPriorityFee = mostRecentResult.prioritizationFee;
         this.lastSlotSeen = mostRecentResult.slot;
-        this.avgPriorityFee =
-            descResults.reduce((a, b) => {
-                return a + b.prioritizationFee;
-            }, 0) / descResults.length;
-        this.maxPriorityFee = Math.max(...descResults.map((result) => result.prioritizationFee));
+        this.lastAvgStrategyResult = this.averageStrategy.calculate(descResults);
+        this.lastMaxStrategyResult = this.maxStrategy.calculate(descResults);
+        if (this.customStrategy) {
+            this.lastCustomStrategyResult =
+                this.customStrategy.calculate(descResults);
+        }
     }
     async unsubscribe() {
         if (this.intervalId) {

package/lib/priorityFee/types.d.ts

@@ -0,0 +1,6 @@
+export interface PriorityFeeStrategy {
+    calculate(samples: {
+        slot: number;
+        prioritizationFee: number;
+    }[]): number;
+}

package/lib/priorityFee/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/slot/SlotSubscriber.d.ts

@@ -1,8 +1,11 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Connection } from '@solana/web3.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types/types/src';
-type SlotSubscriberConfig = {};
+type SlotSubscriberConfig = {
+    resubTimeoutMs?: number;
+};
 export interface SlotSubscriberEvents {
     newSlot: (newSlot: number) => void;
 }
@@ -11,9 +14,14 @@ export declare class SlotSubscriber {
     currentSlot: number;
     subscriptionId: number;
     eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
-    constructor(connection: Connection, _config?: SlotSubscriberConfig);
+    timeoutId?: NodeJS.Timeout;
+    resubTimeoutMs?: number;
+    isUnsubscribing: boolean;
+    receivingData: boolean;
+    constructor(connection: Connection, config?: SlotSubscriberConfig);
     subscribe(): Promise<void>;
+    private setTimeout;
     getSlot(): number;
-    unsubscribe(): Promise<void>;
+    unsubscribe(onResub?: boolean): Promise<void>;
 }
 export {};