@velocity-exchange/sdk 0.4.0 → 0.6.1

package/tests/tx/TransactionConfirmationManager.test.ts

@@ -1,312 +0,0 @@
-import { expect } from 'chai';
-import sinon from 'sinon';
-import {
-	Connection,
-	SignatureStatus,
-	VersionedTransactionResponse,
-} from '@solana/web3.js';
-import { TransactionConfirmationManager } from '../../src/util/TransactionConfirmationManager';
-import assert from 'assert';
-
-describe('TransactionConfirmationManager_Polling_Tests', () => {
-	let manager: TransactionConfirmationManager;
-	let mockConnection: sinon.SinonStubbedInstance<Connection>;
-
-	beforeEach(() => {
-		mockConnection = sinon.createStubInstance(Connection);
-		manager = new TransactionConfirmationManager(
-			mockConnection as unknown as Connection
-		);
-	});
-
-	afterEach(() => {
-		sinon.restore();
-	});
-
-	it('should throw error for invalid poll interval', async () => {
-		try {
-			await manager.confirmTransactionPolling(
-				'fakeTxSig',
-				'confirmed',
-				30000,
-				300
-			);
-			assert.fail('Expected an error to be thrown');
-		} catch (error) {
-			assert(error instanceof Error);
-			assert.strictEqual(
-				error.message,
-				'Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms'
-			);
-		}
-	});
-
-	it('should resolve when transaction is confirmed', async () => {
-		const fakeTxSig = 'fakeTxSig';
-		const fakeStatus: SignatureStatus = {
-			slot: 100,
-			confirmations: 1,
-			err: null,
-			confirmationStatus: 'confirmed',
-		};
-
-		mockConnection.getSignatureStatuses.resolves({
-			context: { slot: 100 },
-			value: [fakeStatus],
-		});
-
-		const result = await manager.confirmTransactionPolling(
-			fakeTxSig,
-			'confirmed',
-			30000,
-			400
-		);
-
-		expect(result).to.deep.equal(fakeStatus);
-		expect(
-			mockConnection.getSignatureStatuses.calledWith([fakeTxSig], {
-				searchTransactionHistory: false,
-			})
-		).to.be.true;
-	});
-
-	it('should reject when transaction fails', async function () {
-		const fakeTxSig = 'fakeTxSig';
-		const fakeStatus: SignatureStatus = {
-			slot: 100,
-			confirmations: 1,
-			err: { InstructionError: [0, 'Custom'] },
-			confirmationStatus: 'confirmed',
-		};
-
-		mockConnection.getSignatureStatuses.resolves({
-			context: { slot: 100 },
-			value: [fakeStatus],
-		});
-
-		// The transaction manager falls into getTransaction when it detects a transaction failure so we need to mock that as well
-		// @ts-ignore
-		mockConnection.getTransaction.resolves({
-			meta: {
-				logMessages: ['Transaction failed: Custom'],
-				err: { InstructionError: [0, 'Custom'] },
-			},
-		} as VersionedTransactionResponse);
-
-		try {
-			await manager.confirmTransactionPolling(
-				fakeTxSig,
-				'confirmed',
-				30000,
-				400
-			);
-			assert.fail('Expected an error to be thrown');
-		} catch (error) {
-			return;
-		}
-	});
-
-	it('should reject on timeout', async () => {
-		const clock = sinon.useFakeTimers();
-
-		const fakeTxSig = 'fakeTxSig';
-		mockConnection.getSignatureStatuses.resolves({
-			context: { slot: 100 },
-			value: [null],
-		});
-
-		const promise = manager.confirmTransactionPolling(
-			fakeTxSig,
-			'confirmed',
-			5000,
-			1000
-		);
-
-		clock.tick(6000);
-
-		try {
-			await promise;
-			assert.fail('Expected an error to be thrown');
-		} catch (error) {
-			assert(error instanceof Error);
-			assert.strictEqual(
-				error.message,
-				'Transaction confirmation timeout after 5000ms'
-			);
-		}
-
-		clock.restore();
-	});
-
-	it('should check multiple transactions together', async () => {
-		const fakeTxSig1 = 'fakeTxSig1';
-		const fakeTxSig2 = 'fakeTxSig2';
-		const fakeStatus1: SignatureStatus = {
-			slot: 100,
-			confirmations: 1,
-			err: null,
-			confirmationStatus: 'confirmed',
-		};
-		const fakeStatus2: SignatureStatus = {
-			slot: 100,
-			confirmations: 1,
-			err: null,
-			confirmationStatus: 'confirmed',
-		};
-
-		mockConnection.getSignatureStatuses.resolves({
-			context: { slot: 100 },
-			value: [fakeStatus1, fakeStatus2],
-		});
-
-		const promise1 = manager.confirmTransactionPolling(
-			fakeTxSig1,
-			'confirmed',
-			30000,
-			400
-		);
-		const promise2 = manager.confirmTransactionPolling(
-			fakeTxSig2,
-			'confirmed',
-			30000,
-			400
-		);
-
-		const clock = sinon.useFakeTimers();
-		clock.tick(400);
-		clock.restore();
-
-		const [result1, result2] = await Promise.all([promise1, promise2]);
-
-		expect(result1).to.deep.equal(fakeStatus1);
-		expect(result2).to.deep.equal(fakeStatus2);
-		expect(
-			mockConnection.getSignatureStatuses.calledWith([fakeTxSig1, fakeTxSig2], {
-				searchTransactionHistory: false,
-			})
-		).to.be.true;
-	});
-
-	it('should have overlapping request for transactions with 400ms and 1200ms intervals on the third 400ms interval', async function () {
-		this.timeout(5000); // Increase timeout for this test to 5 seconds
-
-		const fakeTxSig1 = 'fakeTxSig1'; // 400ms interval
-		const fakeTxSig2 = 'fakeTxSig2'; // 1200ms interval
-		const fakeStatus: SignatureStatus = {
-			slot: 100,
-			confirmations: 1,
-			err: null,
-			confirmationStatus: 'confirmed',
-		};
-
-		let callCount = 0;
-		const callTimes: number[] = [];
-		const callSignatures: string[][] = [];
-
-		mockConnection.getSignatureStatuses = async (signatures) => {
-			callCount++;
-			const currentTime = Date.now();
-			callTimes.push(currentTime);
-			callSignatures.push([...signatures]);
-
-			if (callCount < 3) {
-				return {
-					context: { slot: 100 },
-					value: signatures.map(() => null),
-				};
-			} else {
-				return {
-					context: { slot: 100 },
-					value: signatures.map(() => fakeStatus),
-				};
-			}
-		};
-
-		// Fake timers: the poll intervals (and the Date.now used for callTimes) must
-		// be driven deterministically. The previous real `setTimeout(1250)` wait was
-		// flaky under CI load — a slow runner let an extra 400ms poll fire (4 calls
-		// instead of 3). Ticking fake time aligns the 400ms/1200ms intervals exactly
-		// at 1200ms, so the third poll batches both signatures.
-		const clock = sinon.useFakeTimers();
-		const startTime = Date.now();
-
-		// Start both confirmation processes
-		const promise1 = manager.confirmTransactionPolling(
-			fakeTxSig1,
-			'confirmed',
-			5000,
-			400
-		);
-		const promise2 = manager.confirmTransactionPolling(
-			fakeTxSig2,
-			'confirmed',
-			5000,
-			1200
-		);
-
-		// Advance fake time past the third 400ms interval / first 1200ms interval.
-		await clock.tickAsync(1250);
-
-		// Resolve both promises
-		await Promise.all([promise1, promise2]);
-		clock.restore();
-
-		// Check the call times and signatures
-		assert.strictEqual(callTimes.length, 3, 'Should have exactly 3 calls');
-
-		// Check if the third call is close to 1200ms and includes both signatures
-		const overlapCall = 2; // The third call should be the overlapping one
-		const overlapTime = callTimes[overlapCall] - startTime;
-
-		assert(
-			Math.abs(overlapTime - 1200) < 100,
-			`Overlapping call should be around 1200ms, but was at ${overlapTime}ms`
-		);
-
-		// Verify the call pattern
-		assert(
-			callSignatures[0].includes(fakeTxSig1) &&
-				!callSignatures[0].includes(fakeTxSig2),
-			'First call should only include 400ms interval transaction'
-		);
-		assert(
-			callSignatures[1].includes(fakeTxSig1) &&
-				!callSignatures[1].includes(fakeTxSig2),
-			'Second call should only include 400ms interval transaction'
-		);
-		assert(
-			callSignatures[2].includes(fakeTxSig1) &&
-				callSignatures[2].includes(fakeTxSig2),
-			'Third call should include both transactions'
-		);
-
-		// Wait for 1000ms to check that we haven't made any more calls now that all transactions are confirmed
-		await new Promise((resolve) => setTimeout(resolve, 1000));
-
-		// Verify that no more calls were made
-		assert.strictEqual(
-			callTimes.length,
-			3,
-			'Should not have made any more calls after all transactions are confirmed'
-		);
-
-		// Verify that only the third call returns non-null results
-		callCount = 0;
-		const results = await Promise.all(
-			callSignatures.map((sigs) => mockConnection.getSignatureStatuses!(sigs))
-		);
-
-		assert(
-			results[0].value.every((v) => v === null),
-			'First call should return null results'
-		);
-		assert(
-			results[1].value.every((v) => v === null),
-			'Second call should return null results'
-		);
-		assert(
-			results[2].value.every((v) => v !== null),
-			'Third call should return non-null results'
-		);
-	});
-});

package/tests/tx/cachedBlockhashFetcher.test.ts

@@ -1,96 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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);
-	});
-});