@drift-labs/sdk 2.96.0-beta.2 → 2.96.0-beta.20

package/src/tx/txHandler.ts

@@ -29,6 +29,7 @@ import { CachedBlockhashFetcher } from './blockhashFetcher/cachedBlockhashFetche
 import { BaseBlockhashFetcher } from './blockhashFetcher/baseBlockhashFetcher';
 import { BlockhashFetcher } from './blockhashFetcher/types';
 import { isVersionedTransaction } from './utils';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
 
 /**
  * Explanation for SIGNATURE_BLOCK_AND_EXPIRY:
@@ -81,7 +82,8 @@ export class TxHandler {
 	private preSignedCb?: () => void;
 	private onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
 
-	private blockhashCommitment: Commitment = 'finalized';
+	private blockhashCommitment: Commitment =
+		DEFAULT_CONFIRMATION_OPTS.commitment;
 	private blockHashFetcher: BlockhashFetcher;
 
 	constructor(props: {
@@ -98,6 +100,11 @@ export class TxHandler {
 		this.connection = props.connection;
 		this.wallet = props.wallet;
 		this.confirmationOptions = props.confirmationOptions;
+		this.blockhashCommitment =
+			props.confirmationOptions?.preflightCommitment ??
+			props?.connection?.commitment ??
+			this.blockhashCommitment ??
+			'confirmed';
 
 		this.blockHashFetcher = props?.config?.blockhashCachingEnabled
 			? new CachedBlockhashFetcher(
@@ -536,7 +543,6 @@ export class TxHandler {
 			}
 		} else {
 			const marketLookupTable = await fetchMarketLookupTableAccount();
-
 			lookupTables = lookupTables
 				? [...lookupTables, marketLookupTable]
 				: [marketLookupTable];

package/src/tx/whileValidTxSender.ts

@@ -1,22 +1,20 @@
 import { 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,10 @@ 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>(),
 		additionalTxSenderCallbacks = [],
-		blockhashCommitment = 'finalized',
 		txHandler,
 		trackTxLandRate,
 		txLandRateLookbackWindowMinutes,
@@ -78,7 +74,6 @@ export class WhileValidTxSender extends BaseTxSender {
 		retrySleep?: number;
 		additionalConnections?;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		blockhashCommitment?: Commitment;
 		txHandler?: TxHandler;
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
@@ -96,7 +91,6 @@ export class WhileValidTxSender extends BaseTxSender {
 			landRateToFeeFunc,
 		});
 		this.retrySleep = retrySleep;
-		this.blockhashCommitment = blockhashCommitment;
 
 		this.checkAndSetUseBlockHeightOffset();
 	}
@@ -139,7 +133,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);
 
@@ -193,6 +187,11 @@ export class WhileValidTxSender extends BaseTxSender {
 		const txSig = bs58.encode(signedTx.signatures[0]);
 		this.untilValid.set(txSig, latestBlockhash);
 
+		console.debug(
+			`preflight_commitment`,
+			`sending_tx_with_preflight_commitment::${opts?.preflightCommitment}`
+		);
+
 		return this.sendRawTransaction(signedTx.serialize(), opts);
 	}
 
@@ -202,6 +201,10 @@ export class WhileValidTxSender extends BaseTxSender {
 	): Promise<TxSigAndSlot> {
 		const startTime = this.getTimestamp();
 
+		console.debug(
+			`preflight_commitment`,
+			`sending_tx_with_preflight_commitment::${opts?.preflightCommitment}`
+		);
 		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
 		this.txSigCache?.set(txid, false);
 		this.sendToAdditionalConnections(rawTransaction, opts);
@@ -234,27 +237,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,23 @@ export const DefaultOrderParams: OrderParams = {
 	auctionEndPrice: null,
 };
 
+export type SwiftServerMessage = {
+	slot: BN;
+	swiftOrderSignature: Uint8Array;
+};
+
+export type SwiftOrderParamsMessage = {
+	swiftOrderParams: OptionalOrderParams;
+	expectedOrderId: number;
+	takeProfitOrderParams: SwiftTriggerOrderParams | null;
+	stopLossOrderParams: SwiftTriggerOrderParams | null;
+};
+
+export type SwiftTriggerOrderParams = {
+	triggerPrice: BN;
+	baseAssetAmount: BN;
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	makerStats: PublicKey;
@@ -1070,6 +1092,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 +1124,7 @@ export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;
 	signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
 	publicKey: PublicKey;
+	payer?: Keypair;
 }
 export interface IVersionedWallet {
 	signVersionedTransaction(
@@ -1106,6 +1134,7 @@ export interface IVersionedWallet {
 		txs: VersionedTransaction[]
 	): Promise<VersionedTransaction[]>;
 	publicKey: PublicKey;
+	payer?: Keypair;
 }
 
 export type FeeStructure = {

package/src/user.ts

@@ -78,6 +78,8 @@ import {
 import { calculateMarketOpenBidAsk } from './math/amm';
 import {
 	calculateBaseAssetValueWithOracle,
+	calculateCollateralDepositRequiredForTrade,
+	calculateMarginUSDCRequiredForTrade,
 	calculateWorstCaseBaseAssetAmount,
 } from './math/margin';
 import { OraclePriceData } from './oracles/types';
@@ -98,7 +100,6 @@ import {
 	calculatePerpFuelBonus,
 	calculateInsuranceFuelBonus,
 } from './math/fuel';
-import { grpcUserAccountSubscriber } from './accounts/grpcUserAccountSubscriber';
 
 export class User {
 	driftClient: DriftClient;
@@ -129,16 +130,6 @@ export class User {
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
-		} else if (config.accountSubscription?.type === 'grpc') {
-			this.accountSubscriber = new grpcUserAccountSubscriber(
-				config.accountSubscription.configs,
-				config.driftClient.program,
-				config.userAccountPublicKey,
-				{
-					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
-					logResubMessages: config.accountSubscription?.logResubMessages,
-				}
-			);
 		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
@@ -2285,6 +2276,7 @@ export class User {
 	 * @param estimatedEntryPrice
 	 * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
 	 * @param includeOpenOrders
+	 * @param offsetCollateral // allows calculating the liquidation price after this offset collateral is added to the user's account (e.g. : what will the liquidation price be for this position AFTER I deposit $x worth of collateral)
 	 * @returns Precision : PRICE_PRECISION
 	 */
 	public liquidationPrice(
@@ -2292,7 +2284,8 @@ export class User {
 		positionBaseSizeChange: BN = ZERO,
 		estimatedEntryPrice: BN = ZERO,
 		marginCategory: MarginCategory = 'Maintenance',
-		includeOpenOrders = false
+		includeOpenOrders = false,
+		offsetCollateral = ZERO
 	): BN {
 		const totalCollateral = this.getTotalCollateral(marginCategory);
 		const marginRequirement = this.getMarginRequirement(
@@ -2301,7 +2294,10 @@ export class User {
 			false,
 			includeOpenOrders
 		);
-		let freeCollateral = BN.max(ZERO, totalCollateral.sub(marginRequirement));
+		let freeCollateral = BN.max(
+			ZERO,
+			totalCollateral.sub(marginRequirement)
+		).add(offsetCollateral);
 
 		const oracle =
 			this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
@@ -2604,6 +2600,32 @@ export class User {
 		);
 	}
 
+	public getMarginUSDCRequiredForTrade(
+		targetMarketIndex: number,
+		baseSize: BN
+	): BN {
+		return calculateMarginUSDCRequiredForTrade(
+			this.driftClient,
+			targetMarketIndex,
+			baseSize,
+			this.getUserAccount().maxMarginRatio
+		);
+	}
+
+	public getCollateralDepositRequiredForTrade(
+		targetMarketIndex: number,
+		baseSize: BN,
+		collateralIndex: number
+	): BN {
+		return calculateCollateralDepositRequiredForTrade(
+			this.driftClient,
+			targetMarketIndex,
+			baseSize,
+			collateralIndex,
+			this.getUserAccount().maxMarginRatio
+		);
+	}
+
 	/**
 	 * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
 	 *

package/src/userConfig.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-import { GrpcConfigs, UserAccountSubscriber } from './accounts/types';
+import { UserAccountSubscriber } from './accounts/types';
 
 export type UserConfig = {
 	accountSubscription?: UserSubscriptionConfig;
@@ -23,10 +23,4 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'custom';
 			userAccountSubscriber: UserAccountSubscriber;
-	  }
-	| {
-			type: 'grpc';
-			resubTimeoutMs?: number;
-			logResubMessages?: boolean;
-			configs: GrpcConfigs;
 	  };

package/src/userMap/userMap.ts

@@ -36,7 +36,6 @@ import {
 import { WebsocketSubscription } from './WebsocketSubscription';
 import { PollingSubscription } from './PollingSubscription';
 import { decodeUser } from '../decode/user';
-import { grpcSubscription } from './grpcSubscription';
 
 const MAX_USER_ACCOUNT_SIZE_BYTES = 4376;
 
@@ -76,10 +75,7 @@ export class UserMap implements UserMapInterface {
 	private includeIdle: boolean;
 	private disableSyncOnTotalAccountsChange: boolean;
 	private lastNumberOfSubAccounts: BN;
-	private subscription:
-		| PollingSubscription
-		| WebsocketSubscription
-		| grpcSubscription;
+	private subscription: PollingSubscription | WebsocketSubscription;
 	private stateAccountUpdateCallback = async (state: StateAccount) => {
 		if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
 			await this.sync();
@@ -126,18 +122,6 @@ export class UserMap implements UserMapInterface {
 				frequency: config.subscriptionConfig.frequency,
 				skipInitialLoad: config.skipInitialLoad,
 			});
-		} else if (config.subscriptionConfig.type === 'grpc') {
-			this.subscription = new grpcSubscription({
-				configs: config.subscriptionConfig.configs,
-				userMap: this,
-				commitment: this.commitment,
-				resubOpts: {
-					resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
-					logResubMessages: config.subscriptionConfig.logResubMessages,
-				},
-				skipInitialLoad: config.skipInitialLoad,
-				decodeFn,
-			});
 		} else {
 			this.subscription = new WebsocketSubscription({
 				userMap: this,

package/src/userMap/userMapConfig.ts

@@ -1,6 +1,5 @@
 import { Commitment, Connection } from '@solana/web3.js';
 import { DriftClient } from '../driftClient';
-import { GrpcConfigs } from '../accounts/types';
 
 // passed into UserMap.getUniqueAuthorities to filter users
 export type UserAccountFilterCriteria = {
@@ -28,13 +27,6 @@ export type UserMapConfig = {
 				frequency: number;
 				commitment?: Commitment;
 		  }
-		| {
-				type: 'grpc';
-				configs: GrpcConfigs;
-				resubTimeoutMs?: number;
-				logResubMessages?: boolean;
-				commitment?: Commitment;
-		  }
 		| {
 				type: 'websocket';
 				resubTimeoutMs?: number;

package/src/userStatsConfig.ts

@@ -1,7 +1,6 @@
 import { DriftClient } from './driftClient';
 import { Commitment, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
-import { GrpcConfigs } from './accounts/types';
 
 export type UserStatsConfig = {
 	accountSubscription?: UserStatsSubscriptionConfig;
@@ -22,10 +21,4 @@ export type UserStatsSubscriptionConfig =
 	  }
 	| {
 			type: 'custom';
-	  }
-	| {
-			type: 'grpc';
-			resubTimeoutMs?: number;
-			logResubMessages?: boolean;
-			configs: GrpcConfigs;
 	  };

package/src/util/TransactionConfirmationManager.ts

@@ -0,0 +1,155 @@
+import {
+	Connection,
+	SignatureStatus,
+	TransactionConfirmationStatus,
+} from '@solana/web3.js';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+
+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 confirmTransaction(
+		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 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) {
+				request.reject(
+					new Error(`Transaction failed: ${JSON.stringify(status.err)}`)
+				);
+				this.pendingConfirmations.delete(request.txSig);
+				continue;
+			}
+
+			if (
+				confirmationStatusValues[status.confirmationStatus] === undefined ||
+				confirmationStatusValues[request.desiredConfirmationStatus] ===
+					undefined
+			) {
+				throw new Error(
+					`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`
+				);
+			}
+
+			if (
+				status.confirmationStatus &&
+				confirmationStatusValues[status.confirmationStatus] >=
+					confirmationStatusValues[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`);
+				}
+			}
 		}
 	});