@drift-labs/sdk 2.96.0-beta.8 → 2.97.0-beta.0

package/src/util/TransactionConfirmationManager.ts

@@ -0,0 +1,292 @@
+import {
+	ClientSubscriptionId,
+	Connection,
+	Context,
+	RpcResponseAndContext,
+	SignatureResult,
+	SignatureStatus,
+	TransactionConfirmationStatus,
+} from '@solana/web3.js';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+import { TxSendError } from '..';
+import { NOT_CONFIRMED_ERROR_CODE } from '../constants/txConstants';
+import {
+	getTransactionErrorFromTxSig,
+	throwTransactionError,
+} from '../tx/reportTransactionError';
+import { promiseTimeout } from './promiseTimeout';
+
+type ResolveReference = {
+	resolve?: () => void;
+};
+
+const confirmationStatusValues: Record<TransactionConfirmationStatus, number> =
+	{
+		processed: 0,
+		confirmed: 1,
+		finalized: 2,
+	};
+
+interface TransactionConfirmationRequest {
+	txSig: string;
+	desiredConfirmationStatus: TransactionConfirmationStatus;
+	timeout: number;
+	pollInterval: number;
+	searchTransactionHistory: boolean;
+	startTime: number;
+	resolve: (status: SignatureStatus) => void;
+	reject: (error: Error) => void;
+}
+
+/**
+ * Class to await for transaction confirmations in an optimised manner. It tracks a shared list of all pending transactions and fetches them in bulk in a shared RPC request whenever they have an "overlapping" polling interval. E.g. tx1 with an interval of 200ms and tx2 with an interval of 300ms (if sent at the same time) will be fetched together at at 600ms, 1200ms, 1800ms, etc.
+ */
+export class TransactionConfirmationManager {
+	private connection: Connection;
+	private pendingConfirmations: Map<string, TransactionConfirmationRequest> =
+		new Map();
+	private intervalId: NodeJS.Timeout | null = null;
+
+	constructor(connection: Connection) {
+		this.connection = connection;
+	}
+
+	async confirmTransactionWebSocket(
+		txSig: string,
+		timeout = 30000,
+		desiredConfirmationStatus = DEFAULT_CONFIRMATION_OPTS.commitment as TransactionConfirmationStatus
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		const start = Date.now();
+		const subscriptionCommitment =
+			desiredConfirmationStatus || DEFAULT_CONFIRMATION_OPTS.commitment;
+
+		let response: RpcResponseAndContext<SignatureResult> | null = null;
+
+		let subscriptionId: ClientSubscriptionId;
+
+		const confirmationPromise = new Promise((resolve, reject) => {
+			try {
+				subscriptionId = this.connection.onSignature(
+					txSig,
+					(result: SignatureResult, context: Context) => {
+						response = {
+							context,
+							value: result,
+						};
+						resolve(null);
+					},
+					subscriptionCommitment
+				);
+			} catch (err) {
+				reject(err);
+			}
+		});
+
+		// We do a one-shot confirmation check just in case the transaction is ALREADY confirmed when we create the websocket confirmation .. We want to run this concurrently with the onSignature subscription. If this returns true then we can return early as the transaction has already been confirmed.
+		const oneShotConfirmationPromise = this.connection.getSignatureStatuses([
+			txSig,
+		]);
+
+		const resolveReference: ResolveReference = {};
+
+		// This is the promise we are waiting on to resolve the overall confirmation. It will resolve the faster of a positive oneShot confirmation, or the websocket confirmation, or the timeout.
+		const overallWaitingForConfirmationPromise = new Promise<void>(
+			(resolve) => {
+				resolveReference.resolve = resolve;
+			}
+		);
+
+		// Await for the one shot confirmation and resolve the waiting promise if we get a positive confirmation result
+		oneShotConfirmationPromise.then(
+			async (oneShotResponse) => {
+				if (!oneShotResponse || !oneShotResponse?.value?.[0]) return;
+
+				const resultValue = oneShotResponse.value[0];
+
+				if (resultValue.err) {
+					await throwTransactionError(txSig, this.connection);
+				}
+
+				if (
+					this.checkStatusMatchesDesiredConfirmationStatus(
+						resultValue,
+						desiredConfirmationStatus
+					)
+				) {
+					response = {
+						context: oneShotResponse.context,
+						value: oneShotResponse.value[0],
+					};
+					resolveReference.resolve?.();
+				}
+			},
+			(onRejected) => {
+				throw onRejected;
+			}
+		);
+
+		// Await for the websocket confirmation with the configured timeout
+		promiseTimeout(confirmationPromise, timeout).then(
+			() => {
+				resolveReference.resolve?.();
+			},
+			(onRejected) => {
+				throw onRejected;
+			}
+		);
+
+		try {
+			await overallWaitingForConfirmationPromise;
+		} finally {
+			if (subscriptionId !== undefined) {
+				this.connection.removeSignatureListener(subscriptionId);
+			}
+		}
+
+		const duration = (Date.now() - start) / 1000;
+
+		if (response === null) {
+			throw new TxSendError(
+				`Transaction was not confirmed in ${duration.toFixed(
+					2
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${txSig} using the Solana Explorer or CLI tools.`,
+				NOT_CONFIRMED_ERROR_CODE
+			);
+		}
+
+		return response;
+	}
+
+	async confirmTransactionPolling(
+		txSig: string,
+		desiredConfirmationStatus = DEFAULT_CONFIRMATION_OPTS.commitment as TransactionConfirmationStatus,
+		timeout = 30000,
+		pollInterval = 1000,
+		searchTransactionHistory = false
+	): Promise<SignatureStatus> {
+		// Interval must be > 400ms and a multiple of 100ms
+		if (pollInterval < 400 || pollInterval % 100 !== 0) {
+			throw new Error(
+				'Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms'
+			);
+		}
+
+		return new Promise((resolve, reject) => {
+			this.pendingConfirmations.set(txSig, {
+				txSig,
+				desiredConfirmationStatus,
+				timeout,
+				pollInterval,
+				searchTransactionHistory,
+				startTime: Date.now(),
+				resolve,
+				reject,
+			});
+
+			if (!this.intervalId) {
+				this.startConfirmationLoop();
+			}
+		});
+	}
+
+	private startConfirmationLoop() {
+		this.intervalId = setInterval(() => this.checkPendingConfirmations(), 100);
+	}
+
+	private async checkPendingConfirmations() {
+		const now = Date.now();
+		const transactionsToCheck: TransactionConfirmationRequest[] = [];
+
+		for (const [txSig, request] of this.pendingConfirmations.entries()) {
+			if (now - request.startTime >= request.timeout) {
+				request.reject(
+					new Error(
+						`Transaction confirmation timeout after ${request.timeout}ms`
+					)
+				);
+				this.pendingConfirmations.delete(txSig);
+			} else if ((now - request.startTime) % request.pollInterval < 100) {
+				transactionsToCheck.push(request);
+			}
+		}
+
+		if (transactionsToCheck.length > 0) {
+			await this.checkTransactionStatuses(transactionsToCheck);
+		}
+
+		if (this.pendingConfirmations.size === 0 && this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = null;
+		}
+	}
+
+	private checkStatusMatchesDesiredConfirmationStatus(
+		status: SignatureStatus,
+		desiredConfirmationStatus: TransactionConfirmationStatus
+	): boolean {
+		if (
+			status.confirmationStatus &&
+			confirmationStatusValues[status.confirmationStatus] >=
+				confirmationStatusValues[desiredConfirmationStatus]
+		) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private async checkTransactionStatuses(
+		requests: TransactionConfirmationRequest[]
+	) {
+		const txSigs = requests.map((request) => request.txSig);
+		const { value: statuses } = await this.connection.getSignatureStatuses(
+			txSigs,
+			{
+				searchTransactionHistory: requests.some(
+					(req) => req.searchTransactionHistory
+				),
+			}
+		);
+
+		if (!statuses || statuses.length !== txSigs.length) {
+			throw new Error('Failed to get signature statuses');
+		}
+
+		for (let i = 0; i < statuses.length; i++) {
+			const status = statuses[i];
+			const request = requests[i];
+
+			if (status === null) {
+				continue;
+			}
+
+			if (status.err) {
+				this.pendingConfirmations.delete(request.txSig);
+				request.reject(
+					await getTransactionErrorFromTxSig(request.txSig, this.connection)
+				);
+				continue;
+			}
+
+			if (
+				confirmationStatusValues[status.confirmationStatus] === undefined ||
+				confirmationStatusValues[request.desiredConfirmationStatus] ===
+					undefined
+			) {
+				throw new Error(
+					`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`
+				);
+			}
+
+			if (
+				this.checkStatusMatchesDesiredConfirmationStatus(
+					status,
+					request.desiredConfirmationStatus
+				)
+			) {
+				request.resolve(status);
+				this.pendingConfirmations.delete(request.txSig);
+			}
+		}
+	}
+}

package/tests/ci/idl.ts

@@ -51,7 +51,9 @@ describe('Verify IDL', function () {
 		);
 
 		if (onChainIdl === null) {
-			throw new Error(`onChainIdl for ${mainnetDriftClient.program.programId.toBase58()} null`);
+			throw new Error(
+				`onChainIdl for ${mainnetDriftClient.program.programId.toBase58()} null`
+			);
 		}
 
 		// anchor idl init seems to strip the metadata
@@ -65,13 +67,20 @@ describe('Verify IDL', function () {
 		const encodedSdkIdl = JSON.stringify(sdkIdl);
 
 		try {
-			assert(encodedSdkIdl === encodedMainnetIdl, 'on-chain IDL does not match SDK IDL');
+			assert(
+				encodedSdkIdl === encodedMainnetIdl,
+				'on-chain IDL does not match SDK IDL'
+			);
 		} catch (error) {
 			const diff = {};
 			for (const key of IDL_KEYS_TO_CHECK) {
 				const onChainItems = onChainIdl[key];
 				const sdkItems = sdkIdl[key];
-				for (let i = 0; i < Math.max(onChainItems.length, sdkItems.length); i++) {
+				for (
+					let i = 0;
+					i < Math.max(onChainItems.length, sdkItems.length);
+					i++
+				) {
 					let onChainItem = null;
 					let sdkItem = null;
 					if (i < onChainItems.length) {

package/tests/ci/verifyConstants.ts

@@ -6,6 +6,7 @@ import {
 	MainnetPerpMarkets,
 	BulkAccountLoader,
 	getVariant,
+	isOneOfVariant,
 } from '../../src';
 import { Connection, Keypair } from '@solana/web3.js';
 import { Wallet } from '@coral-xyz/anchor';
@@ -128,6 +129,12 @@ describe('Verify Constants', function () {
 					market.marketIndex
 				} oracle ${market.oracle.toBase58()}`
 			);
+
+			if (isOneOfVariant(market.oracleSource, ['pythPull', 'pyth1KPull', 'pyth1MPull', 'pythStableCoinPull'])) {
+				if (!correspondingConfigMarket.pythFeedId) {
+					assert(false, `spot market ${market.marketIndex} missing feed id`);
+				}
+			}
 		}
 
 		const perpMarkets = mainnetDriftClient.getPerpMarketAccounts();
@@ -177,6 +184,12 @@ describe('Verify Constants', function () {
 					market.marketIndex
 				} oracle ${market.amm.oracle.toBase58()}`
 			);
+
+			if (isOneOfVariant(market.amm.oracleSource, ['pythPull', 'pyth1KPull', 'pyth1MPull', 'pythStableCoinPull'])) {
+				if (!correspondingConfigMarket.pythFeedId) {
+					assert(false, `perp market ${market.marketIndex} missing feed id`);
+				}
+			}
 		}
 	});
 

package/tests/tx/TransactionConfirmationManager.test.ts

@@ -0,0 +1,305 @@
+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),
+				};
+			}
+		};
+
+		const startTime = Date.now();
+
+		// Start both confirmation processes
+		const promise1 = manager.confirmTransactionPolling(
+			fakeTxSig1,
+			'confirmed',
+			5000,
+			400
+		);
+		const promise2 = manager.confirmTransactionPolling(
+			fakeTxSig2,
+			'confirmed',
+			5000,
+			1200
+		);
+
+		// Wait for 1250ms to ensure we've hit the third 400ms interval and first 1200ms interval
+		await new Promise((resolve) => setTimeout(resolve, 1250));
+
+		// Resolve both promises
+		await Promise.all([promise1, promise2]);
+
+		// 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'
+		);
+	});
+});