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

package/src/tx/whileValidTxSender.ts

@@ -1,22 +1,20 @@
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import {
-	Commitment,
 	ConfirmOptions,
 	Connection,
+	SendTransactionError,
 	Signer,
 	Transaction,
 	VersionedTransaction,
 } from '@solana/web3.js';
-import { AnchorProvider } from '@coral-xyz/anchor';
 import { BaseTxSender } from './baseTxSender';
 import bs58 from 'bs58';
 import { TxHandler } from './txHandler';
 import { IWallet } from '../types';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
 
 const DEFAULT_RETRY = 2000;
 
-const VALID_BLOCK_HEIGHT_OFFSET = -150; // This is a bit of weirdness but the lastValidBlockHeight value returned from connection.getLatestBlockhash is always 300 blocks ahead of the current block, even though the transaction actually expires after 150 blocks. This accounts for that so that we can at least accuractely estimate the transaction expiry.
-
 type ResolveReference = {
 	resolve?: () => void;
 };
@@ -33,7 +31,6 @@ export class WhileValidTxSender extends BaseTxSender {
 		string,
 		{ blockhash: string; lastValidBlockHeight: number }
 	>();
-	blockhashCommitment: Commitment;
 
 	useBlockHeightOffset = true;
 
@@ -62,11 +59,11 @@ export class WhileValidTxSender extends BaseTxSender {
 	public constructor({
 		connection,
 		wallet,
-		opts = { ...AnchorProvider.defaultOptions(), maxRetries: 0 },
+		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
 		retrySleep = DEFAULT_RETRY,
 		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
 		additionalTxSenderCallbacks = [],
-		blockhashCommitment = 'finalized',
 		txHandler,
 		trackTxLandRate,
 		txLandRateLookbackWindowMinutes,
@@ -78,7 +75,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		retrySleep?: number;
 		additionalConnections?;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		blockhashCommitment?: Commitment;
+		confirmationStrategy?: ConfirmationStrategy;
 		txHandler?: TxHandler;
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
@@ -93,10 +90,10 @@ export class WhileValidTxSender extends BaseTxSender {
 			txHandler,
 			trackTxLandRate,
 			txLandRateLookbackWindowMinutes,
+			confirmationStrategy,
 			landRateToFeeFunc,
 		});
 		this.retrySleep = retrySleep;
-		this.blockhashCommitment = blockhashCommitment;
 
 		this.checkAndSetUseBlockHeightOffset();
 	}
@@ -139,7 +136,7 @@ export class WhileValidTxSender extends BaseTxSender {
 
 		// handle subclass-specific side effects
 		const txSig = bs58.encode(
-			signedTx.signatures[0]?.signature || signedTx.signatures[0]
+			signedTx?.signature || signedTx.signatures[0]?.signature
 		);
 		this.untilValid.set(txSig, latestBlockhash);
 
@@ -234,27 +231,21 @@ export class WhileValidTxSender extends BaseTxSender {
 
 		let slot: number;
 		try {
-			const { blockhash, lastValidBlockHeight } = this.untilValid.get(txid);
-
-			const result = await this.connection.confirmTransaction(
-				{
-					signature: txid,
-					blockhash,
-					lastValidBlockHeight: this.useBlockHeightOffset
-						? lastValidBlockHeight + VALID_BLOCK_HEIGHT_OFFSET
-						: lastValidBlockHeight,
-				},
-				opts?.commitment
-			);
-
-			if (!result) {
-				throw new Error(`Couldn't get signature status for txid: ${txid}`);
-			}
+			const result = await this.confirmTransaction(txid, opts.commitment);
 
 			this.txSigCache?.set(txid, true);
 
 			await this.checkConfirmationResultForError(txid, result.value);
 
+			if (result?.value?.err) {
+				// Fallback error handling if there's a problem reporting the error in checkConfirmationResultForError
+				throw new SendTransactionError({
+					action: 'send',
+					signature: txid,
+					transactionMessage: `Transaction Failed`,
+				});
+			}
+
 			slot = result.context.slot;
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {

package/src/types.ts

@@ -1,4 +1,9 @@
-import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import {
+	Keypair,
+	PublicKey,
+	Transaction,
+	VersionedTransaction,
+} from '@solana/web3.js';
 import { BN, ZERO } from '.';
 
 // Utility type which lets you denote record with values of type A mapped to a record with the same keys but values of type B
@@ -1051,6 +1056,24 @@ export const DefaultOrderParams: OrderParams = {
 	auctionEndPrice: null,
 };
 
+export type SwiftServerMessage = {
+	slot: BN;
+	swiftOrderSignature: Uint8Array;
+};
+
+export type SwiftOrderParamsMessage = {
+	swiftOrderParams: OptionalOrderParams;
+	expectedOrderId: number;
+	subAccountId: number;
+	takeProfitOrderParams: SwiftTriggerOrderParams | null;
+	stopLossOrderParams: SwiftTriggerOrderParams | null;
+};
+
+export type SwiftTriggerOrderParams = {
+	triggerPrice: BN;
+	baseAssetAmount: BN;
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	makerStats: PublicKey;
@@ -1070,6 +1093,11 @@ export type ReferrerInfo = {
 	referrerStats: PublicKey;
 };
 
+export enum PlaceAndTakeOrderSuccessCondition {
+	PartialFill = 1,
+	FullFill = 2,
+}
+
 type ExactType<T> = Pick<T, keyof T>;
 
 export type BaseTxParams = ExactType<{
@@ -1097,6 +1125,7 @@ export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;
 	signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
 	publicKey: PublicKey;
+	payer?: Keypair;
 }
 export interface IVersionedWallet {
 	signVersionedTransaction(
@@ -1106,6 +1135,7 @@ export interface IVersionedWallet {
 		txs: VersionedTransaction[]
 	): Promise<VersionedTransaction[]>;
 	publicKey: PublicKey;
+	payer?: Keypair;
 }
 
 export type FeeStructure = {

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