@drift-labs/sdk 2.38.1-beta.11 → 2.38.1-beta.13

package/VERSION

@@ -1 +1 @@
-2.38.1-beta.11
+2.38.1-beta.13

package/lib/index.d.ts

@@ -65,6 +65,7 @@ export * from './priorityFee/priorityFeeSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';
 export * from './util/tps';

package/lib/index.js

@@ -88,6 +88,7 @@ __exportStar(require("./priorityFee/priorityFeeSubscriber"), exports);
 __exportStar(require("./phoenix/phoenixFulfillmentConfigMap"), exports);
 __exportStar(require("./tx/fastSingleTxSender"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
+__exportStar(require("./tx/priorityFeeCalculator"), exports);
 __exportStar(require("./tx/types"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);

package/lib/tx/priorityFeeCalculator.d.ts

@@ -0,0 +1,44 @@
+import { TransactionInstruction } from '@solana/web3.js';
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+export declare class PriorityFeeCalculator {
+    lastTxTimeoutCount: number;
+    priorityFeeTriggered: boolean;
+    lastTxTimeoutCountTriggered: number;
+    priorityFeeLatchDurationMs: number;
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs: number, priorityFeeLatchDurationMs?: number);
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs: number, txTimeoutCount: number): boolean;
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit: number): Array<TransactionInstruction>;
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit: number, additionalFeeMicroLamports: number): number;
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit: number, usePriorityFee: boolean, additionalFeeMicroLamports: number): Array<TransactionInstruction>;
+}

package/lib/tx/priorityFeeCalculator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityFeeCalculator = void 0;
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+class PriorityFeeCalculator {
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs, priorityFeeLatchDurationMs = 10 * 1000) {
+        this.lastTxTimeoutCount = 0;
+        this.priorityFeeTriggered = false;
+        this.lastTxTimeoutCountTriggered = currentTimeMs;
+        this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
+    }
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs, txTimeoutCount) {
+        let triggerPriorityFee = false;
+        if (txTimeoutCount > this.lastTxTimeoutCount) {
+            this.lastTxTimeoutCount = txTimeoutCount;
+            this.lastTxTimeoutCountTriggered = currentTimeMs;
+            triggerPriorityFee = true;
+        }
+        else {
+            if (!this.priorityFeeTriggered) {
+                triggerPriorityFee = false;
+            }
+            else if (currentTimeMs - this.lastTxTimeoutCountTriggered <
+                this.priorityFeeLatchDurationMs) {
+                triggerPriorityFee = true;
+            }
+        }
+        this.priorityFeeTriggered = triggerPriorityFee;
+        return triggerPriorityFee;
+    }
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit) {
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: computeUnitLimit,
+            }),
+        ];
+        return ixs;
+    }
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit, additionalFeeMicroLamports) {
+        return additionalFeeMicroLamports / computeUnitLimit;
+    }
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit, usePriorityFee, additionalFeeMicroLamports) {
+        const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
+        if (usePriorityFee) {
+            const computeUnitPrice = this.calculateComputeUnitPrice(computeUnitLimit, additionalFeeMicroLamports);
+            ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: computeUnitPrice,
+            }));
+        }
+        return ixs;
+    }
+}
+exports.PriorityFeeCalculator = PriorityFeeCalculator;

package/lib/user.js

@@ -1834,7 +1834,7 @@ class User {
             const spotMarketAccount = this.driftClient.getQuoteSpotMarketAccount();
             const oraclePriceData = this.getOracleDataForSpotMarket(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
             const baseAssetValue = (0, _1.getTokenValue)(netQuoteValue, spotMarketAccount.decimals, oraclePriceData);
-            const { weight, weightedTokenValue } = (0, spotPosition_1.calculateWeightedTokenValue)(netQuoteValue, baseAssetValue, oraclePriceData, spotMarketAccount, marginCategory);
+            const { weight, weightedTokenValue } = (0, spotPosition_1.calculateWeightedTokenValue)(netQuoteValue, baseAssetValue, oraclePriceData.price, spotMarketAccount, marginCategory);
             if (netQuoteValue.lt(numericConstants_1.ZERO)) {
                 healthComponents.borrows.push({
                     marketIndex: spotMarketAccount.marketIndex,

package/package.json

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

package/src/index.ts

@@ -66,6 +66,7 @@ export * from './priorityFee/priorityFeeSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';
 export * from './util/tps';

package/src/tx/priorityFeeCalculator.ts

@@ -0,0 +1,117 @@
+import { ComputeBudgetProgram, TransactionInstruction } from '@solana/web3.js';
+
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+export class PriorityFeeCalculator {
+	lastTxTimeoutCount: number;
+	priorityFeeTriggered: boolean;
+	lastTxTimeoutCountTriggered: number;
+	priorityFeeLatchDurationMs: number; // how long to stay in triggered state before resetting
+
+	/**
+	 * Constructor for the PriorityFeeCalculator class.
+	 * @param currentTimeMs - The current time in milliseconds.
+	 * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+	 */
+	constructor(
+		currentTimeMs: number,
+		priorityFeeLatchDurationMs: number = 10 * 1000
+	) {
+		this.lastTxTimeoutCount = 0;
+		this.priorityFeeTriggered = false;
+		this.lastTxTimeoutCountTriggered = currentTimeMs;
+		this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
+	}
+
+	/**
+	 * Update the priority fee state based on the current time and the current timeout count.
+	 * @param currentTimeMs current time in milliseconds
+	 * @returns true if priority fee should be included in the next transaction
+	 */
+	public updatePriorityFee(
+		currentTimeMs: number,
+		txTimeoutCount: number
+	): boolean {
+		let triggerPriorityFee = false;
+
+		if (txTimeoutCount > this.lastTxTimeoutCount) {
+			this.lastTxTimeoutCount = txTimeoutCount;
+			this.lastTxTimeoutCountTriggered = currentTimeMs;
+			triggerPriorityFee = true;
+		} else {
+			if (!this.priorityFeeTriggered) {
+				triggerPriorityFee = false;
+			} else if (
+				currentTimeMs - this.lastTxTimeoutCountTriggered <
+				this.priorityFeeLatchDurationMs
+			) {
+				triggerPriorityFee = true;
+			}
+		}
+
+		this.priorityFeeTriggered = triggerPriorityFee;
+
+		return triggerPriorityFee;
+	}
+
+	/**
+	 * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+	 * @returns An array of transaction instructions.
+	 */
+	public generateComputeBudgetIxs(
+		computeUnitLimit: number
+	): Array<TransactionInstruction> {
+		const ixs = [
+			ComputeBudgetProgram.setComputeUnitLimit({
+				units: computeUnitLimit,
+			}),
+		];
+
+		return ixs;
+	}
+
+	/**
+	 * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+	 * @param computeUnitLimit desired CU to use
+	 * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+	 * @returns the compute unit price to use, in micro lamports
+	 */
+	public calculateComputeUnitPrice(
+		computeUnitLimit: number,
+		additionalFeeMicroLamports: number
+	): number {
+		return additionalFeeMicroLamports / computeUnitLimit;
+	}
+
+	/**
+	 * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+	 * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+	 * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+	 * @returns An array of transaction instructions.
+	 */
+	public generateComputeBudgetWithPriorityFeeIx(
+		computeUnitLimit: number,
+		usePriorityFee: boolean,
+		additionalFeeMicroLamports: number
+	): Array<TransactionInstruction> {
+		const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
+
+		if (usePriorityFee) {
+			const computeUnitPrice = this.calculateComputeUnitPrice(
+				computeUnitLimit,
+				additionalFeeMicroLamports
+			);
+			ixs.push(
+				ComputeBudgetProgram.setComputeUnitPrice({
+					microLamports: computeUnitPrice,
+				})
+			);
+		}
+
+		return ixs;
+	}
+}

package/src/user.ts

@@ -3320,7 +3320,7 @@ export class User {
 			const { weight, weightedTokenValue } = calculateWeightedTokenValue(
 				netQuoteValue,
 				baseAssetValue,
-				oraclePriceData,
+				oraclePriceData.price,
 				spotMarketAccount,
 				marginCategory
 			);

package/tests/tx/priorityFeeCalculator.ts

@@ -0,0 +1,77 @@
+import { expect } from 'chai';
+import { PriorityFeeCalculator } from '../../src/tx/priorityFeeCalculator';
+
+describe('PriorityFeeCalculator', () => {
+	let priorityFeeCalculator: PriorityFeeCalculator;
+
+	const startTime = 1000000;
+	const latch_duration = 10_000;
+
+	beforeEach(() => {
+		priorityFeeCalculator = new PriorityFeeCalculator(
+			startTime,
+			latch_duration
+		);
+	});
+
+	it('should trigger priority fee when timeout count increases', () => {
+		const timeoutCount = 1;
+		expect(priorityFeeCalculator.updatePriorityFee(startTime, timeoutCount)).to
+			.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration,
+				timeoutCount + 1
+			)
+		).to.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration,
+				timeoutCount + 2
+			)
+		).to.be.true;
+	});
+
+	it('should trigger priority fee when timeout count increases, and stay latched until latch duration', () => {
+		const timeoutCount = 1;
+		expect(priorityFeeCalculator.updatePriorityFee(startTime, timeoutCount)).to
+			.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration / 2,
+				timeoutCount
+			)
+		).to.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration - 1,
+				timeoutCount
+			)
+		).to.be.true;
+		expect(
+			priorityFeeCalculator.updatePriorityFee(
+				startTime + latch_duration * 2,
+				timeoutCount
+			)
+		).to.be.false;
+	});
+
+	it('should not trigger priority fee when timeout count does not increase', () => {
+		const timeoutCount = 0;
+		expect(priorityFeeCalculator.updatePriorityFee(startTime, timeoutCount)).to
+			.be.false;
+	});
+
+	it('should correctly calculate compute unit price', () => {
+		const computeUnitLimit = 1_000_000;
+		const additionalFeeMicroLamports = 1_000_000_000; // 1000 lamports
+		const actualComputeUnitPrice =
+			priorityFeeCalculator.calculateComputeUnitPrice(
+				computeUnitLimit,
+				additionalFeeMicroLamports
+			);
+		expect(actualComputeUnitPrice * computeUnitLimit).to.equal(
+			additionalFeeMicroLamports
+		);
+	});
+});