@drift-labs/sdk 2.52.0-beta.5 → 2.52.0-beta.6

package/VERSION

@@ -1 +1 @@
-2.52.0-beta.5
+2.52.0-beta.6

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/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.52.0-beta.5",
+	"version": "2.52.0-beta.6",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/priorityFee/averageOverSlotsStrategy.ts

@@ -0,0 +1,30 @@
+import { PriorityFeeStrategy } from './types';
+
+export class AverageOverSlotsStrategy implements PriorityFeeStrategy {
+	private lookbackSlots: number;
+
+	/**
+	 * @param lookbackSlots The number of slots to look back from the max slot in the sample
+	 */
+	constructor(lookbackSlots = 10) {
+		this.lookbackSlots = lookbackSlots;
+	}
+
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		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;
+	}
+}

package/src/priorityFee/averageStrategy.ts

@@ -0,0 +1,11 @@
+import { PriorityFeeStrategy } from './types';
+
+export class AverageStrategy implements PriorityFeeStrategy {
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		return (
+			samples.reduce((a, b) => {
+				return a + b.prioritizationFee;
+			}, 0) / samples.length
+		);
+	}
+}

package/src/priorityFee/ewmaStrategy.ts

@@ -0,0 +1,40 @@
+import { PriorityFeeStrategy } from './types';
+
+class EwmaStrategy implements PriorityFeeStrategy {
+	private halfLife: number;
+
+	/**
+	 * @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: { slot: number; prioritizationFee: number }[]): number {
+		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;
+	}
+}
+
+export { EwmaStrategy };

package/src/priorityFee/maxOverSlotsStrategy.ts

@@ -0,0 +1,31 @@
+import { PriorityFeeStrategy } from './types';
+
+export class MaxOverSlotsStrategy implements PriorityFeeStrategy {
+	private lookbackSlots: number;
+
+	/**
+	 * @param lookbackSlots The number of slots to look back from the max slot in the sample
+	 */
+	constructor(lookbackSlots = 10) {
+		this.lookbackSlots = lookbackSlots;
+	}
+
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		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;
+	}
+}

package/src/priorityFee/maxStrategy.ts

@@ -0,0 +1,7 @@
+import { PriorityFeeStrategy } from './types';
+
+export class MaxStrategy implements PriorityFeeStrategy {
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number {
+		return Math.max(...samples.map((result) => result.prioritizationFee));
+	}
+}

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -1,35 +1,63 @@
 import { Connection, PublicKey } from '@solana/web3.js';
+import { PriorityFeeStrategy } from './types';
+import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
+import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
 
 export class PriorityFeeSubscriber {
 	connection: Connection;
 	frequencyMs: number;
 	addresses: PublicKey[];
-	slotsToCheck: number;
+	customStrategy?: PriorityFeeStrategy;
+	averageStrategy = new AverageOverSlotsStrategy();
+	maxStrategy = new MaxOverSlotsStrategy();
 
 	intervalId?: ReturnType<typeof setTimeout>;
 
 	latestPriorityFee = 0;
-	// avg of last {slotsToCheck} slots
-	avgPriorityFee = 0;
-	// max of last {slotsToCheck} slots
-	maxPriorityFee = 0;
+	lastStrategyResult = 0;
+	lastCustomStrategyResult = 0;
+	lastAvgStrategyResult = 0;
+	lastMaxStrategyResult = 0;
 	lastSlotSeen = 0;
 
 	public constructor({
 		connection,
 		frequencyMs,
 		addresses,
+		customStrategy,
 		slotsToCheck = 10,
 	}: {
 		connection: Connection;
 		frequencyMs: number;
 		addresses: PublicKey[];
+		customStrategy?: PriorityFeeStrategy;
 		slotsToCheck?: number;
 	}) {
 		this.connection = connection;
 		this.frequencyMs = frequencyMs;
 		this.addresses = addresses;
-		this.slotsToCheck = slotsToCheck;
+		if (slotsToCheck) {
+			this.averageStrategy = new AverageOverSlotsStrategy(slotsToCheck);
+			this.maxStrategy = new MaxOverSlotsStrategy(slotsToCheck);
+		}
+		if (customStrategy) {
+			this.customStrategy = customStrategy;
+		}
+	}
+
+	public get avgPriorityFee(): number {
+		return this.lastAvgStrategyResult;
+	}
+
+	public get maxPriorityFee(): number {
+		return this.lastMaxStrategyResult;
+	}
+
+	public get customPriorityFee(): number {
+		if (!this.customStrategy) {
+			console.error('Custom strategy not set');
+		}
+		return this.lastCustomStrategyResult;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -47,23 +75,22 @@ export class PriorityFeeSubscriber {
 			[this.addresses]
 		);
 
-		const descResults: { slot: number; prioritizationFee: number }[] =
-			rpcJSONResponse?.result
-				?.sort((a, b) => b.slot - a.slot)
-				?.slice(0, this.slotsToCheck) ?? [];
-
-		if (!descResults?.length) return;
+		// getRecentPrioritizationFees returns results unsorted
+		const results: { slot: number; prioritizationFee: number }[] =
+			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);
+		}
 	}
 
 	public async unsubscribe(): Promise<void> {

package/src/priorityFee/types.ts

@@ -0,0 +1,5 @@
+export interface PriorityFeeStrategy {
+	// calculate the priority fee for a given set of samples.
+	// expect samples to be sorted in descending order (by slot)
+	calculate(samples: { slot: number; prioritizationFee: number }[]): number;
+}

package/tests/tx/priorityFeeStrategy.ts

@@ -0,0 +1,97 @@
+import { expect } from 'chai';
+import { AverageStrategy } from '../../src/priorityFee/averageStrategy';
+import { MaxStrategy } from '../../src/priorityFee/maxStrategy';
+import { EwmaStrategy } from '../../src/priorityFee/ewmaStrategy';
+import { MaxOverSlotsStrategy } from '../../src/priorityFee/maxOverSlotsStrategy';
+import { AverageOverSlotsStrategy } from '../../src/priorityFee/averageOverSlotsStrategy';
+
+describe('PriorityFeeStrategy', () => {
+    it('AverageStrategy should calculate the average prioritization fee', () => {
+        const averageStrategy = new AverageStrategy();
+        const samples = [
+            { slot: 3, prioritizationFee: 300 },
+            { slot: 2, prioritizationFee: 200 },
+            { slot: 1, prioritizationFee: 100 },
+        ];
+        const average = averageStrategy.calculate(samples);
+        expect(average).to.equal(200);
+    });
+
+    it('MaxStrategy should calculate the maximum prioritization fee', () => {
+        const maxStrategy = new MaxStrategy();
+        const samples = [
+            { slot: 3, prioritizationFee: 300 },
+            { slot: 2, prioritizationFee: 200 },
+            { slot: 1, prioritizationFee: 100 },
+        ];
+        const max = maxStrategy.calculate(samples);
+        expect(max).to.equal(300);
+    });
+
+    it('EwmaStrategy should calculate the ewma prioritization fee', () => {
+        // halflife of 5 alots
+        const ewmaStrategy = new EwmaStrategy(5);
+        const samples = [
+            { slot: 6, prioritizationFee: 0 },
+            { slot: 2, prioritizationFee: 0 },
+            { slot: 2, prioritizationFee: 0 },
+            { slot: 2, prioritizationFee: 0 },
+            { slot: 2, prioritizationFee: 0 },
+            { slot: 1, prioritizationFee: 1000 },
+        ];
+        const ewma = ewmaStrategy.calculate(samples);
+        expect(ewma).to.be.approximately(500, 0.00001);
+    });
+
+    it('EwmaStrategy should calculate the ewma prioritization fee, length 1', () => {
+        // halflife of 5 alots
+        const ewmaStrategy = new EwmaStrategy(5);
+        const samples = [
+            { slot: 6, prioritizationFee: 1000 },
+        ];
+        const ewma = ewmaStrategy.calculate(samples);
+        expect(ewma).to.be.approximately(1000, 0.00001);
+    });
+
+    it('EwmaStrategy should calculate the ewma prioritization fee, length 6', () => {
+        const ewmaStrategy = new EwmaStrategy(5);
+        const samples = [
+            { slot: 6, prioritizationFee: 1000 },
+            { slot: 5, prioritizationFee: 570 },
+            { slot: 4, prioritizationFee: 860 },
+            { slot: 3, prioritizationFee: 530 },
+            { slot: 2, prioritizationFee: 701 },
+            { slot: 1, prioritizationFee: 230 },
+        ];
+        const ewma = ewmaStrategy.calculate(samples);
+        expect(ewma).to.be.approximately(490.43706, 0.00001);
+    });
+
+    it('MaxOverSlotsStrategy should calculate the max prioritization fee over slots', () => {
+        const maxOverSlotsStrategy = new MaxOverSlotsStrategy(5);
+        const samples = [
+            { slot: 6, prioritizationFee: 432 },
+            { slot: 3, prioritizationFee: 543 },
+            { slot: 3, prioritizationFee: 342 },
+            { slot: 3, prioritizationFee: 832 },
+            { slot: 2, prioritizationFee: 123 },
+            { slot: 1, prioritizationFee: 1000 },
+        ];
+        const maxOverSlots = maxOverSlotsStrategy.calculate(samples);
+        expect(maxOverSlots).to.equal(832);
+    });
+
+    it('AverageOverSlotsStrategy should calculate the average prioritization fee over slots', () => {
+        const averageOverSlotsStrategy = new AverageOverSlotsStrategy(5);
+        const samples = [
+            { slot: 6, prioritizationFee: 432 },
+            { slot: 3, prioritizationFee: 543 },
+            { slot: 3, prioritizationFee: 342 },
+            { slot: 3, prioritizationFee: 832 },
+            { slot: 2, prioritizationFee: 123 },
+            { slot: 1, prioritizationFee: 1000 },
+        ];
+        const averageOverSlots = averageOverSlotsStrategy.calculate(samples);
+        expect(averageOverSlots).to.equal(454.4);
+    });
+});

package/tests/user/helpers.ts

@@ -26,6 +26,7 @@ export const mockOrder: Order = {
 	price: ZERO,
 	baseAssetAmount: ZERO,
 	baseAssetAmountFilled: ZERO,
+	quoteAssetAmount: ZERO,
 	quoteAssetAmountFilled: ZERO,
 	direction: PositionDirection.LONG,
 	reduceOnly: false,