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

package/src/tx/reportTransactionError.ts

@@ -0,0 +1,159 @@
+import {
+	Commitment,
+	Connection,
+	Finality,
+	SendTransactionError,
+	VersionedTransactionResponse,
+} from '@solana/web3.js';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+
+/**
+ * The new getTransaction method expects a Finality type instead of a Commitment type. The only options for Finality are 'confirmed' and 'finalized'.
+ * @param commitment
+ * @returns
+ */
+const commitmentToFinality = (commitment: Commitment): Finality => {
+	switch (commitment) {
+		case 'confirmed':
+			return 'confirmed';
+		case 'finalized':
+			return 'finalized';
+		default:
+			throw new Error(
+				`Invalid commitment when reporting transaction error. The commitment must be 'confirmed' or 'finalized' but was given '${commitment}'. If you're using this commitment for a specific reason, you may need to roll your own logic here.`
+			);
+	}
+};
+
+const getTransactionResult = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<VersionedTransactionResponse> => {
+	const finality = commitmentToFinality(
+		commitment || connection.commitment || DEFAULT_CONFIRMATION_OPTS.commitment
+	);
+	return await connection.getTransaction(txSig, {
+		maxSupportedTransactionVersion: 0,
+		commitment: finality,
+	});
+};
+
+const getTransactionResultWithRetry = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<VersionedTransactionResponse> => {
+	const start = Date.now();
+
+	const retryTimeout = 3_000; // Timeout after 3 seconds
+	const retryInterval = 800; // Retry with 800ms interval
+	const retryCount = 3; // Retry 3 times
+
+	let currentCount = 0;
+	let transactionResult = await getTransactionResult(
+		txSig,
+		connection,
+		commitment
+	);
+
+	// Retry 3 times or until timeout as long as we don't have a result yet
+	while (
+		!transactionResult &&
+		Date.now() - start < retryTimeout &&
+		currentCount < retryCount
+	) {
+		// Sleep for 1 second :: Do this first so that we don't run the first loop immediately after the initial fetch above
+		await new Promise((resolve) => setTimeout(resolve, retryInterval));
+
+		transactionResult = await getTransactionResult(
+			txSig,
+			connection,
+			commitment
+		);
+		currentCount++;
+	}
+
+	return transactionResult;
+};
+
+/**
+ * THROWS if there is an error
+ *
+ * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
+ * @param txSig
+ * @param connection
+ * @returns
+ */
+export const throwTransactionError = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<void> => {
+	const err = await getTransactionErrorFromTxSig(txSig, connection, commitment);
+
+	if (err) {
+		throw err;
+	}
+
+	return;
+};
+
+/**
+ * RETURNS an error if there is one
+ *
+ * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
+ * @param txSig
+ * @param connection
+ * @returns
+ */
+export const getTransactionErrorFromTxSig = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<SendTransactionError> => {
+	const transactionResult = await getTransactionResultWithRetry(
+		txSig,
+		connection,
+		commitment
+	);
+
+	if (!transactionResult) {
+		// Throw a generic error because we couldn't get the transaction result for the given txSig
+		return new SendTransactionError({
+			action: 'send',
+			signature: txSig,
+			transactionMessage: `Transaction Failed`,
+		});
+	}
+
+	if (!transactionResult?.meta?.err) {
+		// Assume that the transaction was successful and we are here erroneously because we have a result with no error
+		return;
+	}
+
+	return getTransactionError(transactionResult);
+};
+
+export const getTransactionError = (
+	transactionResult: VersionedTransactionResponse
+): SendTransactionError => {
+	if (!transactionResult?.meta?.err) {
+		return;
+	}
+
+	const logs = transactionResult?.meta?.logMessages ?? ['No logs'];
+
+	const lastLog = logs[logs.length - 1];
+
+	const friendlyMessage = lastLog?.match(/(failed:) (.+)/)?.[2];
+
+	return new SendTransactionError({
+		action: 'send',
+		signature: transactionResult?.transaction?.signatures?.[0],
+		transactionMessage: `Transaction Failed${
+			friendlyMessage ? `: ${friendlyMessage}` : ''
+		}`,
+		logs,
+	});
+};

package/src/tx/retryTxSender.ts

@@ -1,9 +1,9 @@
 import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import { ConfirmOptions, Connection } from '@solana/web3.js';
-import { AnchorProvider } from '@coral-xyz/anchor';
 import { BaseTxSender } from './baseTxSender';
 import { TxHandler } from './txHandler';
 import { IWallet } from '../types';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
 
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 2000;
@@ -24,7 +24,7 @@ export class RetryTxSender extends BaseTxSender {
 	public constructor({
 		connection,
 		wallet,
-		opts = { ...AnchorProvider.defaultOptions(), maxRetries: 0 },
+		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
 		timeout = DEFAULT_TIMEOUT,
 		retrySleep = DEFAULT_RETRY,
 		additionalConnections = new Array<Connection>(),

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 { 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/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';
@@ -2274,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(
@@ -2281,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(
@@ -2290,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;
@@ -2593,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.
 	 *