@drift-labs/sdk-browser 2.104.0-beta.21

package/tests/tx/cachedBlockhashFetcher.test.ts

@@ -0,0 +1,96 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import {
+	Connection,
+	Commitment,
+	BlockhashWithExpiryBlockHeight,
+} from '@solana/web3.js';
+import { CachedBlockhashFetcher } from '../../src/tx/blockhashFetcher/cachedBlockhashFetcher';
+
+describe('CachedBlockhashFetcher', () => {
+	let connection: sinon.SinonStubbedInstance<Connection>;
+	let cachedBlockhashFetcher: CachedBlockhashFetcher;
+	const mockBlockhash: BlockhashWithExpiryBlockHeight = {
+		blockhash: 'mockedBlockhash',
+		lastValidBlockHeight: 1000,
+	};
+
+	beforeEach(() => {
+		connection = sinon.createStubInstance(Connection);
+		connection.getLatestBlockhash.resolves(mockBlockhash);
+
+		cachedBlockhashFetcher = new CachedBlockhashFetcher(
+			connection as unknown as Connection,
+			'confirmed' as Commitment,
+			3,
+			100,
+			1000
+		);
+	});
+
+	afterEach(() => {
+		sinon.restore();
+	});
+
+	it('should fetch and cache the latest blockhash', async () => {
+		const result = await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(result).to.deep.equal(mockBlockhash);
+		expect(connection.getLatestBlockhash.calledOnce).to.be.true;
+	});
+
+	it('should use cached blockhash if not stale', async () => {
+		await cachedBlockhashFetcher.getLatestBlockhash();
+		await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(connection.getLatestBlockhash.calledOnce).to.be.true;
+	});
+
+	it('should refresh blockhash if cache is stale', async () => {
+		const clock = sinon.useFakeTimers();
+
+		await cachedBlockhashFetcher.getLatestBlockhash();
+
+		// Advance time to make cache stale
+		clock.tick(1100);
+
+		await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(connection.getLatestBlockhash.calledTwice).to.be.true;
+
+		clock.restore();
+	});
+
+	it('should retry on failure', async () => {
+		connection.getLatestBlockhash
+			.onFirstCall()
+			.rejects(new Error('Network error'))
+			.onSecondCall()
+			.rejects(new Error('Network error'))
+			.onThirdCall()
+			.resolves(mockBlockhash);
+
+		const result = await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(result).to.deep.equal(mockBlockhash);
+		expect(connection.getLatestBlockhash.calledThrice).to.be.true;
+	});
+
+	it('should throw error after maximum retries', async () => {
+		connection.getLatestBlockhash.rejects(new Error('Network error'));
+
+		try {
+			await cachedBlockhashFetcher.getLatestBlockhash();
+			expect.fail('Should have thrown an error');
+		} catch (error) {
+			expect(error.message).to.equal(
+				'Failed to fetch blockhash after maximum retries'
+			);
+		}
+		expect(connection.getLatestBlockhash.calledThrice).to.be.true;
+	});
+
+	it('should prevent concurrent requests for the same blockhash', async () => {
+		const promise1 = cachedBlockhashFetcher.getLatestBlockhash();
+		const promise2 = cachedBlockhashFetcher.getLatestBlockhash();
+
+		await Promise.all([promise1, promise2]);
+		expect(connection.getLatestBlockhash.calledOnce).to.be.true;
+	});
+});

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
+		);
+	});
+});

package/tests/tx/priorityFeeStrategy.ts

@@ -0,0 +1,95 @@
+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();
+		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(1000);
+	});
+
+	it('AverageOverSlotsStrategy should calculate the average prioritization fee over slots', () => {
+		const averageOverSlotsStrategy = new AverageOverSlotsStrategy();
+		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.approximately(545.33333, 0.00001);
+	});
+});

package/tests/user/helpers.ts

@@ -0,0 +1,92 @@
+import { PublicKey } from '@solana/web3.js';
+
+import {
+	SpotPosition,
+	SpotBalanceType,
+	Order,
+	OrderStatus,
+	MarketType,
+	OrderType,
+	PositionDirection,
+	OrderTriggerCondition,
+	UserAccount,
+	ZERO,
+	MarginMode,
+} from '../../src';
+
+import { mockPerpPosition } from '../dlob/helpers';
+
+export const mockOrder: Order = {
+	status: OrderStatus.INIT,
+	orderType: OrderType.MARKET,
+	marketType: MarketType.PERP,
+	slot: ZERO,
+	orderId: 0,
+	userOrderId: 0,
+	marketIndex: 0,
+	price: ZERO,
+	baseAssetAmount: ZERO,
+	baseAssetAmountFilled: ZERO,
+	quoteAssetAmount: ZERO,
+	quoteAssetAmountFilled: ZERO,
+	direction: PositionDirection.LONG,
+	reduceOnly: false,
+	triggerPrice: ZERO,
+	triggerCondition: OrderTriggerCondition.ABOVE,
+	existingPositionDirection: PositionDirection.LONG,
+	postOnly: false,
+	immediateOrCancel: false,
+	oraclePriceOffset: 0,
+	auctionDuration: 0,
+	auctionStartPrice: ZERO,
+	auctionEndPrice: ZERO,
+	maxTs: ZERO,
+};
+
+export const mockSpotPosition: SpotPosition = {
+	marketIndex: 0,
+	balanceType: SpotBalanceType.DEPOSIT,
+	scaledBalance: ZERO,
+	openOrders: 0,
+	openBids: ZERO,
+	openAsks: ZERO,
+	cumulativeDeposits: ZERO,
+};
+
+export const mockUserAccount: UserAccount = {
+	authority: PublicKey.default,
+	delegate: PublicKey.default,
+	name: [1],
+	subAccountId: 0,
+	spotPositions: Array.from({ length: 8 }, function () {
+		return Object.assign({}, mockSpotPosition);
+	}),
+	perpPositions: Array.from({ length: 8 }, function () {
+		return Object.assign({}, mockPerpPosition);
+	}),
+	orders: Array.from({ length: 8 }, function () {
+		return Object.assign({}, mockOrder);
+	}),
+	status: 0,
+	nextLiquidationId: 0,
+	nextOrderId: 0,
+	maxMarginRatio: 0,
+	lastAddPerpLpSharesTs: ZERO,
+	settledPerpPnl: ZERO,
+	totalDeposits: ZERO,
+	totalWithdraws: ZERO,
+	totalSocialLoss: ZERO,
+	cumulativePerpFunding: ZERO,
+	cumulativeSpotFees: ZERO,
+	liquidationMarginFreed: ZERO,
+	lastActiveSlot: ZERO,
+	isMarginTradingEnabled: true,
+	idle: false,
+	openOrders: 0,
+	hasOpenOrder: false,
+	openAuctions: 0,
+	hasOpenAuction: false,
+	lastFuelBonusUpdateTs: 0,
+	marginMode: MarginMode.DEFAULT,
+	poolId: 0,
+};