@drift-labs/sdk 2.83.0-beta.1 → 2.83.0-beta.11

package/src/math/orders.ts

@@ -7,7 +7,7 @@ import {
 	Order,
 	PositionDirection,
 } from '../types';
-import { ZERO, TWO } from '../constants/numericConstants';
+import { ZERO, TWO, ONE } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -160,7 +160,10 @@ export function getLimitPrice(
 	if (hasAuctionPrice(order, slot)) {
 		limitPrice = getAuctionPrice(order, slot, oraclePriceData.price);
 	} else if (order.oraclePriceOffset !== 0) {
-		limitPrice = oraclePriceData.price.add(new BN(order.oraclePriceOffset));
+		limitPrice = BN.max(
+			oraclePriceData.price.add(new BN(order.oraclePriceOffset)),
+			ONE
+		);
 	} else if (order.price.eq(ZERO)) {
 		limitPrice = fallbackPrice;
 	} else {

package/src/phoenix/phoenixSubscriber.ts

@@ -10,6 +10,7 @@ import {
 import { PRICE_PRECISION } from '../constants/numericConstants';
 import { BN } from '@coral-xyz/anchor';
 import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
+import { fastDecode } from '../decode/phoenix';
 
 export type PhoenixMarketSubscriberConfig = {
 	connection: Connection;
@@ -24,6 +25,7 @@ export type PhoenixMarketSubscriberConfig = {
 		| {
 				type: 'websocket';
 		  };
+	fastDecode?: boolean;
 };
 
 export class PhoenixSubscriber implements L2OrderBookGenerator {
@@ -36,7 +38,8 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 	market: Market;
 	marketCallbackId: string | number;
 	clockCallbackId: string | number;
-
+	// fastDecode omits trader data from the markets for faster decoding process
+	fastDecode: boolean;
 	subscribed: boolean;
 	lastSlot: number;
 	lastUnixTimestamp: number;
@@ -53,6 +56,7 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 		}
 		this.lastSlot = 0;
 		this.lastUnixTimestamp = 0;
+		this.fastDecode = config.fastDecode ?? true;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -76,7 +80,11 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 				this.marketAddress,
 				(accountInfo, _ctx) => {
 					try {
-						this.market = this.market.reload(accountInfo.data);
+						if (this.fastDecode) {
+							this.market.data = fastDecode(accountInfo.data);
+						} else {
+							this.market = this.market.reload(accountInfo.data);
+						}
 					} catch {
 						console.error('Failed to reload Phoenix market data');
 					}
@@ -101,7 +109,11 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 					try {
 						this.lastSlot = slot;
 						if (buffer) {
-							this.market = this.market.reload(buffer);
+							if (this.fastDecode) {
+								this.market.data = fastDecode(buffer);
+							} else {
+								this.market = this.market.reload(buffer);
+							}
 						}
 					} catch {
 						console.error('Failed to reload Phoenix market data');

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -96,8 +96,8 @@ export class PriorityFeeSubscriber {
 			return;
 		}
 
+		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs); // we set the intervalId first, preventing a side effect of unsubscribing failing during the race condition where unsubscribes happens before subscribe is finished
 		await this.load();
-		this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
 	}
 
 	private async loadForSolana(): Promise<void> {

package/src/tx/baseTxSender.ts

@@ -15,6 +15,10 @@ import {
 	TransactionSignature,
 	Connection,
 	VersionedTransaction,
+	SendTransactionError,
+	TransactionInstruction,
+	AddressLookupTableAccount,
+	BlockhashWithExpiryBlockHeight,
 } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import assert from 'assert';
@@ -53,7 +57,7 @@ export abstract class BaseTxSender implements TxSender {
 		additionalConnections?;
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		txHandler: TxHandler;
+		txHandler?: TxHandler;
 	}) {
 		this.connection = connection;
 		this.wallet = wallet;
@@ -62,7 +66,13 @@ export abstract class BaseTxSender implements TxSender {
 		this.additionalConnections = additionalConnections;
 		this.confirmationStrategy = confirmationStrategy;
 		this.additionalTxSenderCallbacks = additionalTxSenderCallbacks;
-		this.txHandler = txHandler;
+		this.txHandler =
+			txHandler ??
+			new TxHandler({
+				connection: this.connection,
+				wallet: this.wallet,
+				confirmationOptions: this.opts,
+			});
 	}
 
 	async send(
@@ -103,6 +113,21 @@ export abstract class BaseTxSender implements TxSender {
 		);
 	}
 
+	async getVersionedTransaction(
+		ixs: TransactionInstruction[],
+		lookupTableAccounts: AddressLookupTableAccount[],
+		_additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions,
+		blockhash?: BlockhashWithExpiryBlockHeight
+	): Promise<VersionedTransaction> {
+		return this.txHandler.generateVersionedTransaction(
+			blockhash,
+			ixs,
+			lookupTableAccounts,
+			this.wallet
+		);
+	}
+
 	async sendVersionedTransaction(
 		tx: VersionedTransaction,
 		additionalSigners?: Array<Signer>,
@@ -342,4 +367,36 @@ export abstract class BaseTxSender implements TxSender {
 	public getTimeoutCount(): number {
 		return this.timeoutCount;
 	}
+
+	public async checkConfirmationResultForError(
+		txSig: string,
+		result: RpcResponseAndContext<SignatureResult>
+	) {
+		if (result.value.err) {
+			await this.reportTransactionError(txSig);
+		}
+
+		return;
+	}
+
+	public async reportTransactionError(txSig: string) {
+		const transactionResult = await this.connection.getTransaction(txSig, {
+			maxSupportedTransactionVersion: 0,
+		});
+
+		if (!transactionResult?.meta?.err) {
+			return undefined;
+		}
+
+		const logs = transactionResult.meta.logMessages;
+
+		const lastLog = logs[logs.length - 1];
+
+		const friendlyMessage = lastLog?.match(/(failed:) (.+)/)?.[2];
+
+		throw new SendTransactionError(
+			`Transaction Failed${friendlyMessage ? `: ${friendlyMessage}` : ''}`,
+			transactionResult.meta.logMessages
+		);
+	}
 }

package/src/tx/fastSingleTxSender.ts

@@ -48,7 +48,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		skipConfirmation?: boolean;
 		blockhashCommitment?: Commitment;
 		confirmationStrategy?: ConfirmationStrategy;
-		txHandler: TxHandler;
+		txHandler?: TxHandler;
 	}) {
 		super({
 			connection,
@@ -101,6 +101,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		if (!this.skipConfirmation) {
 			try {
 				const result = await this.confirmTransaction(txid, opts.commitment);
+				await this.checkConfirmationResultForError(txid, result);
 				slot = result.context.slot;
 			} catch (e) {
 				console.error(e);

package/src/tx/forwardOnlyTxSender.ts

@@ -43,7 +43,7 @@ export class ForwardOnlyTxSender extends BaseTxSender {
 		retrySleep?: number;
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		txHandler: TxHandler;
+		txHandler?: TxHandler;
 	}) {
 		super({
 			connection,

package/src/tx/retryTxSender.ts

@@ -40,7 +40,7 @@ export class RetryTxSender extends BaseTxSender {
 		additionalConnections?;
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		txHandler: TxHandler;
+		txHandler?: TxHandler;
 	}) {
 		super({
 			connection,
@@ -105,6 +105,9 @@ export class RetryTxSender extends BaseTxSender {
 		let slot: number;
 		try {
 			const result = await this.confirmTransaction(txid, opts.commitment);
+
+			await this.checkConfirmationResultForError(txid, result);
+
 			slot = result.context.slot;
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {

package/src/tx/txHandler.ts

@@ -23,6 +23,7 @@ import {
 	SignedTxData,
 	TxParams,
 } from '../types';
+import { containsComputeUnitIxs } from '../util/computeUnits';
 
 export const COMPUTE_UNITS_DEFAULT = 200_000;
 
@@ -50,6 +51,7 @@ export class TxHandler {
 	private wallet: IWallet;
 	private confirmationOptions: ConfirmOptions;
 
+	private preSignedCb?: () => void;
 	private onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
 
 	constructor(props: {
@@ -59,6 +61,7 @@ export class TxHandler {
 		opts?: {
 			returnBlockHeightsWithSignedTxCallbackData?: boolean;
 			onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
+			preSignedCb?: () => void;
 		};
 	}) {
 		this.connection = props.connection;
@@ -69,6 +72,7 @@ export class TxHandler {
 		this.returnBlockHeightsWithSignedTxCallbackData =
 			props.opts?.returnBlockHeightsWithSignedTxCallbackData ?? false;
 		this.onSignedCb = props.opts?.onSignedCb;
+		this.preSignedCb = props.opts?.preSignedCb;
 	}
 
 	private addHashAndExpiryToLookup(
@@ -177,6 +181,8 @@ export class TxHandler {
 				tx.partialSign(kp);
 			});
 
+		this.preSignedCb?.();
+
 		const signedTx = await wallet.signTransaction(tx);
 
 		// Turn txSig Buffer into base58 string
@@ -213,6 +219,8 @@ export class TxHandler {
 				tx.sign([kp]);
 			});
 
+		this.preSignedCb?.();
+
 		//@ts-ignore
 		const signedTx = (await wallet.signTransaction(tx)) as VersionedTransaction;
 
@@ -406,10 +414,16 @@ export class TxHandler {
 			};
 		}
 
+		const instructionsArray = Array.isArray(instructions)
+			? instructions
+			: [instructions];
+		const { hasSetComputeUnitLimitIx, hasSetComputeUnitPriceIx } =
+			containsComputeUnitIxs(instructionsArray);
+
 		// # Create Tx Instructions
 		const allIx = [];
 		const computeUnits = baseTxParams?.computeUnits;
-		if (computeUnits !== 200_000) {
+		if (computeUnits > 0 && !hasSetComputeUnitLimitIx) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitLimit({
 					units: computeUnits,
@@ -419,7 +433,7 @@ export class TxHandler {
 
 		const computeUnitsPrice = baseTxParams?.computeUnitsPrice;
 
-		if (computeUnitsPrice !== 0) {
+		if (computeUnitsPrice > 0 && !hasSetComputeUnitPriceIx) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitPrice({
 					microLamports: computeUnitsPrice,
@@ -427,11 +441,7 @@ export class TxHandler {
 			);
 		}
 
-		if (Array.isArray(instructions)) {
-			allIx.push(...instructions);
-		} else {
-			allIx.push(instructions);
-		}
+		allIx.push(...instructionsArray);
 
 		const recentBlockHash =
 			props?.recentBlockHash ?? (await this.getLatestBlockhashForTransaction());
@@ -572,6 +582,8 @@ export class TxHandler {
 			}
 		});
 
+		this.preSignedCb?.();
+
 		const signedTxs = await wallet.signAllTransactions(
 			txsToSign
 				.map((tx) => {

package/src/tx/types.ts

@@ -1,7 +1,10 @@
 import {
+	AddressLookupTableAccount,
+	BlockhashWithExpiryBlockHeight,
 	ConfirmOptions,
 	Signer,
 	Transaction,
+	TransactionInstruction,
 	TransactionSignature,
 	VersionedTransaction,
 } from '@solana/web3.js';
@@ -35,6 +38,14 @@ export interface TxSender {
 		preSigned?: boolean
 	): Promise<TxSigAndSlot>;
 
+	getVersionedTransaction(
+		ixs: TransactionInstruction[],
+		lookupTableAccounts: AddressLookupTableAccount[],
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions,
+		blockhash?: BlockhashWithExpiryBlockHeight
+	): Promise<VersionedTransaction>;
+
 	sendRawTransaction(
 		rawTransaction: Buffer | Uint8Array,
 		opts: ConfirmOptions

package/src/tx/whileValidTxSender.ts

@@ -50,7 +50,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		additionalConnections?;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		blockhashCommitment?: Commitment;
-		txHandler: TxHandler;
+		txHandler?: TxHandler;
 	}) {
 		super({
 			connection,
@@ -190,6 +190,9 @@ export class WhileValidTxSender extends BaseTxSender {
 				},
 				opts.commitment
 			);
+
+			await this.checkConfirmationResultForError(txid, result);
+
 			slot = result.context.slot;
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {

package/src/types.ts

@@ -234,6 +234,11 @@ export class StakeAction {
 	static readonly STAKE_TRANSFER = { stakeTransfer: {} };
 }
 
+export class SettlePnlMode {
+	static readonly TRY_SETTLE = { trySettle: {} };
+	static readonly MUST_SETTLE = { mustSettle: {} };
+}
+
 export function isVariant(object: unknown, type: string) {
 	return object.hasOwnProperty(type);
 }
@@ -1187,6 +1192,7 @@ export type HealthComponent = {
 
 export interface DriftClientMetricsEvents {
 	txSigned: SignedTxData[];
+	preTxSigned: void;
 }
 
 export type SignedTxData = {

package/src/util/computeUnits.ts

@@ -1,4 +1,10 @@
-import { Connection, Finality, PublicKey } from '@solana/web3.js';
+import {
+	ComputeBudgetProgram,
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
 
 export async function findComputeUnitConsumption(
 	programId: PublicKey,
@@ -19,3 +25,39 @@ export async function findComputeUnitConsumption(
 	});
 	return computeUnits;
 }
+
+export function isSetComputeUnitsIx(ix: TransactionInstruction): boolean {
+	// Compute budget program discriminator is first byte
+	// 2: set compute unit limit
+	// 3: set compute unit price
+	if (
+		ix.programId.equals(ComputeBudgetProgram.programId) &&
+		ix.data.at(0) === 2
+	) {
+		return true;
+	}
+	return false;
+}
+
+export function isSetComputeUnitPriceIx(ix: TransactionInstruction): boolean {
+	// Compute budget program discriminator is first byte
+	// 2: set compute unit limit
+	// 3: set compute unit price
+	if (
+		ix.programId.equals(ComputeBudgetProgram.programId) &&
+		ix.data.at(0) === 3
+	) {
+		return true;
+	}
+	return false;
+}
+
+export function containsComputeUnitIxs(ixs: TransactionInstruction[]): {
+	hasSetComputeUnitLimitIx: boolean;
+	hasSetComputeUnitPriceIx: boolean;
+} {
+	return {
+		hasSetComputeUnitLimitIx: ixs.some(isSetComputeUnitsIx),
+		hasSetComputeUnitPriceIx: ixs.some(isSetComputeUnitPriceIx),
+	};
+}

package/tests/decode/phoenix.ts

@@ -0,0 +1,71 @@
+import { MarketData, deserializeMarketData } from '@ellipsis-labs/phoenix-sdk';
+import { fastDecode } from '../../src/decode/phoenix';
+import { Connection, PublicKey } from '@solana/web3.js';
+import assert from 'assert';
+
+describe('custom phoenix decode', function () {
+	this.timeout(100_000);
+
+	it('decodes quickly', async function () {
+		const connection = new Connection('https://api.mainnet-beta.solana.com');
+
+		const val = await connection.getAccountInfo(
+			new PublicKey('4DoNfFBfF7UokCC2FQzriy7yHK6DY6NVdYpuekQ5pRgg')
+		);
+
+		const numIterations = 100;
+
+		let regularDecoded: MarketData;
+		const regularStart = performance.now();
+		for (let i = 0; i < numIterations; i++) {
+			regularDecoded = deserializeMarketData(val!.data);
+		}
+		const regularEnd = performance.now();
+
+		let fastDecoded: MarketData;
+		const fastStart = performance.now();
+		for (let i = 0; i < numIterations; i++) {
+			fastDecoded = fastDecode(val!.data);
+		}
+		const fastEnd = performance.now();
+
+		console.log(`Regular: ${regularEnd - regularStart} ms`);
+		console.log(
+			`Regular avg: ${(regularEnd - regularStart) / numIterations} ms`
+		);
+
+		console.log(`Fast: ${fastEnd - fastStart} ms`);
+		console.log(`Fast avg: ${(fastEnd - fastStart) / numIterations} ms`);
+
+		// @ts-ignore
+		assert(deepEqual(fastDecoded.bids, regularDecoded.bids));
+		// @ts-ignore
+		assert(deepEqual(regularDecoded.asks, fastDecoded.asks));
+	});
+});
+
+function deepEqual(obj1: any, obj2: any) {
+	if (obj1 === obj2) return true;
+
+	if (
+		obj1 == null ||
+		obj2 == null ||
+		typeof obj1 !== 'object' ||
+		typeof obj2 !== 'object'
+	) {
+		return false;
+	}
+
+	const keys1 = Object.keys(obj1);
+	const keys2 = Object.keys(obj2);
+
+	if (keys1.length !== keys2.length) return false;
+
+	for (const key of keys1) {
+		if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+			return false;
+		}
+	}
+
+	return true;
+}