@drift-labs/sdk 2.77.0-beta.0 → 2.77.0-beta.2

package/lib/tx/whileValidTxSender.js

@@ -9,6 +9,7 @@ const anchor_1 = require("@coral-xyz/anchor");
 const baseTxSender_1 = require("./baseTxSender");
 const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_RETRY = 2000;
+const PLACEHOLDER_BLOCKHASH = 'Fdum64WVeej6DeL85REV9NvfSxEJNPZ74DBk7A8kTrKP';
 class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
     constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), additionalTxSenderCallbacks = [], }) {
         super({
@@ -48,10 +49,10 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
         this.untilValid.set(txSig, latestBlockhash);
         return signedTx;
     }
-    async getVersionedTransaction(ixs, lookupTableAccounts, _additionalSigners, _opts) {
+    async getVersionedTransaction(ixs, lookupTableAccounts, _additionalSigners, _opts, blockhash) {
         const message = new web3_js_1.TransactionMessage({
             payerKey: this.wallet.publicKey,
-            recentBlockhash: '',
+            recentBlockhash: blockhash !== null && blockhash !== void 0 ? blockhash : PLACEHOLDER_BLOCKHASH,
             instructions: ixs,
         }).compileToV0Message(lookupTableAccounts);
         const tx = new web3_js_1.VersionedTransaction(message);
@@ -59,18 +60,19 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
     }
     async sendVersionedTransaction(tx, additionalSigners, opts, preSigned, extraConfirmationOptions) {
         const latestBlockhash = await this.connection.getLatestBlockhash();
-        tx.message.recentBlockhash = latestBlockhash.blockhash;
         let signedTx;
         if (preSigned) {
             signedTx = tx;
             // @ts-ignore
         }
         else if (this.wallet.payer) {
+            tx.message.recentBlockhash = latestBlockhash.blockhash;
             // @ts-ignore
             tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.wallet.payer));
             signedTx = tx;
         }
         else {
+            tx.message.recentBlockhash = latestBlockhash.blockhash;
             additionalSigners === null || additionalSigners === void 0 ? void 0 : additionalSigners.filter((s) => s !== undefined).forEach((kp) => {
                 tx.sign([kp]);
             });

package/lib/types.d.ts

@@ -1038,10 +1038,15 @@ export type ReferrerInfo = {
     referrer: PublicKey;
     referrerStats: PublicKey;
 };
-export type TxParams = {
+export type BaseTxParams = {
     computeUnits?: number;
     computeUnitsPrice?: number;
 };
+export type ProcessingTxParams = {
+    useSimulatedComputeUnits?: boolean;
+    computeUnitsBufferMultiplier?: number;
+};
+export type TxParams = BaseTxParams & ProcessingTxParams;
 export declare class SwapReduceOnly {
     static readonly In: {
         in: {};

package/lib/user.js

@@ -1690,8 +1690,14 @@ class User {
         const feeTier = this.getUserFeeTier(marketType);
         let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
         let makerFee = feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
-        if (marketIndex !== undefined && (0, types_1.isVariant)(marketType, 'perp')) {
-            const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+        if (marketIndex !== undefined) {
+            let marketAccount = null;
+            if ((0, types_1.isVariant)(marketType, 'perp')) {
+                marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+            }
+            else {
+                marketAccount = this.driftClient.getSpotMarketAccount(marketIndex);
+            }
             takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
             makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.77.0-beta.0",
+	"version": "2.77.0-beta.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/driftClient.ts

@@ -42,6 +42,8 @@ import {
 	PhoenixV1FulfillmentConfigAccount,
 	ModifyOrderPolicy,
 	SwapReduceOnly,
+	BaseTxParams,
+	ProcessingTxParams,
 } from './types';
 import * as anchor from '@coral-xyz/anchor';
 import driftIDL from './idl/drift.json';
@@ -125,6 +127,7 @@ import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { getMarinadeDepositIx, getMarinadeFinanceProgram } from './marinade';
 import { getOrderParams } from './orderParams';
 import { numberToSafeBN } from './math/utils';
+import { TransactionProcessor as TransactionParamProcessor } from './tx/txParamProcessor';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -734,10 +737,44 @@ export class DriftClient {
 		return result;
 	}
 
+	private async getProcessedTransactionParams(
+		txParams: {
+			instructions: TransactionInstruction | TransactionInstruction[];
+			txParams?: BaseTxParams;
+			txVersion?: TransactionVersion;
+			lookupTables?: AddressLookupTableAccount[];
+		},
+		txParamProcessingParams: ProcessingTxParams
+	): Promise<BaseTxParams> {
+		const tx = await TransactionParamProcessor.process({
+			txProps: {
+				instructions: txParams.instructions,
+				txParams: txParams.txParams,
+				txVersion: txParams.txVersion,
+				lookupTables: txParams.lookupTables,
+			},
+			txBuilder: (updatedTxParams) =>
+				this.buildTransaction(
+					updatedTxParams.instructions,
+					updatedTxParams?.txParams,
+					updatedTxParams.txVersion,
+					updatedTxParams.lookupTables,
+					true
+				) as Promise<VersionedTransaction>,
+			processConfig: txParamProcessingParams,
+			processParams: {
+				connection: this.connection,
+			},
+		});
+
+		return tx;
+	}
+
 	public async initializeUserAccount(
 		subAccountId = 0,
 		name?: string,
-		referrerInfo?: ReferrerInfo
+		referrerInfo?: ReferrerInfo,
+		txParams?: TxParams
 	): Promise<[TransactionSignature, PublicKey]> {
 		const initializeIxs = [];
 
@@ -757,7 +794,7 @@ export class DriftClient {
 		}
 
 		initializeIxs.push(initializeUserAccountIx);
-		const tx = await this.buildTransaction(initializeIxs);
+		const tx = await this.buildTransaction(initializeIxs, txParams);
 
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 
@@ -1992,17 +2029,6 @@ export class DriftClient {
 
 		const isSolMarket = spotMarket.mint.equals(WRAPPED_SOL_MINT);
 
-		let params: TxParams = {
-			computeUnits: txParams?.computeUnits ?? 600_000,
-		};
-
-		if (txParams?.computeUnitsPrice) {
-			params = {
-				...params,
-				computeUnitsPrice: txParams.computeUnitsPrice,
-			};
-		}
-
 		const authority = this.wallet.publicKey;
 
 		const isFromSubaccount =
@@ -2090,7 +2116,7 @@ export class DriftClient {
 			);
 		}
 
-		const tx = await this.buildTransaction(ixs, params);
+		const tx = await this.buildTransaction(ixs, txParams);
 
 		const { txSig, slot } = await this.sendTransaction(
 			tx,
@@ -2110,7 +2136,8 @@ export class DriftClient {
 		marketIndex: number,
 		tokenFaucet: TokenFaucet,
 		amount: BN,
-		referrerInfo?: ReferrerInfo
+		referrerInfo?: ReferrerInfo,
+		txParams?: TxParams
 	): Promise<[TransactionSignature, PublicKey]> {
 		const ixs = [];
 
@@ -2147,7 +2174,7 @@ export class DriftClient {
 		}
 		ixs.push(initializeUserAccountIx, depositCollateralIx);
 
-		const tx = await this.buildTransaction(ixs);
+		const tx = await this.buildTransaction(ixs, txParams);
 
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 
@@ -2231,10 +2258,11 @@ export class DriftClient {
 			);
 		}
 
-		const tx = await this.buildTransaction(withdrawIxs, {
-			...(txParams ?? this.txParams),
-			computeUnits: 1_400_000,
-		});
+		const tx = await this.buildTransaction(
+			withdrawIxs,
+			txParams ?? this.txParams
+		);
+
 		const { txSig, slot } = await this.sendTransaction(
 			tx,
 			additionalSigners,
@@ -4535,15 +4563,37 @@ export class DriftClient {
 			ixs.push(bracketOrdersIx);
 		}
 
-		const placeAndTakeTx = (await this.buildTransaction(
+		const shouldUseSimulationComputeUnits = txParams?.useSimulatedComputeUnits;
+		const shouldExitIfSimulationFails = simulateFirst;
+
+		const txParamsWithoutImplicitSimulation = {
+			...txParams,
+			useSimulationComputeUnits: false,
+		};
+
+		let placeAndTakeTx = await this.buildTransaction(
 			ixs,
-			txParams
-		)) as VersionedTransaction;
+			txParamsWithoutImplicitSimulation
+		);
+
+		if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
+			const simulationResult =
+				await TransactionParamProcessor.getTxSimComputeUnits(
+					// @ts-ignore :: TODO - TEST WITH LEGACY TRANSACTION
+					placeAndTakeTx,
+					this.connection
+				);
 
-		// if param is passed, return early before the tx fails so ui can fallback to placeOrder
-		if (simulateFirst) {
-			const success = await this.txSender.simulateTransaction(placeAndTakeTx);
-			if (!success) return;
+			if (shouldExitIfSimulationFails && !simulationResult.success) {
+				return;
+			}
+
+			if (shouldUseSimulationComputeUnits) {
+				placeAndTakeTx = await this.buildTransaction(ixs, {
+					...txParamsWithoutImplicitSimulation,
+					computeUnits: simulationResult.computeUnits,
+				});
+			}
 		}
 
 		let cancelExistingOrdersTx: Transaction;
@@ -6504,7 +6554,11 @@ export class DriftClient {
 			  }
 			: undefined;
 
-		if (tx instanceof VersionedTransaction) {
+		const version = (tx as VersionedTransaction)?.version;
+		const isVersionedTx =
+			tx instanceof VersionedTransaction || version !== undefined;
+
+		if (isVersionedTx) {
 			return this.txSender.sendVersionedTransaction(
 				tx as VersionedTransaction,
 				additionalSigners,
@@ -6523,14 +6577,65 @@ export class DriftClient {
 		}
 	}
 
+	/**
+	 *
+	 * @param instructions
+	 * @param txParams
+	 * @param txVersion
+	 * @param lookupTables
+	 * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+	 * @returns
+	 */
 	async buildTransaction(
 		instructions: TransactionInstruction | TransactionInstruction[],
 		txParams?: TxParams,
 		txVersion?: TransactionVersion,
-		lookupTables?: AddressLookupTableAccount[]
+		lookupTables?: AddressLookupTableAccount[],
+		forceVersionedTransaction?: boolean
 	): Promise<Transaction | VersionedTransaction> {
+		txVersion = txVersion ?? this.txVersion;
+
+		// # Collect and process Tx Params
+		let baseTxParams: BaseTxParams = {
+			computeUnits: txParams?.computeUnits ?? this.txParams.computeUnits,
+			computeUnitsPrice:
+				txParams?.computeUnitsPrice ?? this.txParams.computeUnitsPrice,
+		};
+
+		if (txParams?.useSimulatedComputeUnits) {
+			const splitTxParams: {
+				baseTxParams: BaseTxParams;
+				txParamProcessingParams: ProcessingTxParams;
+			} = {
+				baseTxParams: {
+					computeUnits: txParams?.computeUnits,
+					computeUnitsPrice: txParams?.computeUnitsPrice,
+				},
+				txParamProcessingParams: {
+					useSimulatedComputeUnits: txParams?.useSimulatedComputeUnits,
+					computeUnitsBufferMultiplier: txParams?.computeUnitsBufferMultiplier,
+				},
+			};
+
+			const processedTxParams = await this.getProcessedTransactionParams(
+				{
+					instructions,
+					txParams: splitTxParams.baseTxParams,
+					txVersion,
+					lookupTables,
+				},
+				splitTxParams.txParamProcessingParams
+			);
+
+			baseTxParams = {
+				...baseTxParams,
+				...processedTxParams,
+			};
+		}
+
+		// # Create Tx Instructions
 		const allIx = [];
-		const computeUnits = txParams?.computeUnits ?? this.txParams.computeUnits;
+		const computeUnits = baseTxParams?.computeUnits;
 		if (computeUnits !== 200_000) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitLimit({
@@ -6538,8 +6643,7 @@ export class DriftClient {
 				})
 			);
 		}
-		const computeUnitsPrice =
-			txParams?.computeUnitsPrice ?? this.txParams.computeUnitsPrice;
+		const computeUnitsPrice = baseTxParams?.computeUnitsPrice;
 		if (computeUnitsPrice !== 0) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitPrice({
@@ -6554,9 +6658,24 @@ export class DriftClient {
 			allIx.push(instructions);
 		}
 
-		txVersion = txVersion ?? this.txVersion;
+		const latestBlockHashAndContext =
+			await this.connection.getLatestBlockhashAndContext({
+				commitment: this.opts.preflightCommitment,
+			});
+
+		// # Create and return Transaction
 		if (txVersion === 'legacy') {
-			return new Transaction().add(...allIx);
+			if (forceVersionedTransaction) {
+				const message = new TransactionMessage({
+					payerKey: this.provider.wallet.publicKey,
+					recentBlockhash: latestBlockHashAndContext.value.blockhash,
+					instructions: allIx,
+				}).compileToLegacyMessage();
+
+				return new VersionedTransaction(message);
+			} else {
+				return new Transaction().add(...allIx);
+			}
 		} else {
 			const marketLookupTable = await this.fetchMarketLookupTableAccount();
 			lookupTables = lookupTables
@@ -6564,11 +6683,7 @@ export class DriftClient {
 				: [marketLookupTable];
 			const message = new TransactionMessage({
 				payerKey: this.provider.wallet.publicKey,
-				recentBlockhash: (
-					await this.provider.connection.getRecentBlockhash(
-						this.opts.preflightCommitment
-					)
-				).blockhash,
+				recentBlockhash: latestBlockHashAndContext.value.blockhash,
 				instructions: allIx,
 			}).compileToV0Message(lookupTables);
 

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.76.0",
+  "version": "2.75.0",
   "name": "drift",
   "instructions": [
     {

package/src/priorityFee/driftPriorityFeeMethod.ts

@@ -5,11 +5,19 @@ export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
 
 export async function fetchDriftPriorityFee(
 	url: string,
-	marketType: string,
-	marketIndex: number
+	marketTypes: string[],
+	marketIndexs: number[]
 ): Promise<DriftPriorityFeeResponse> {
-	const response = await fetch(
-		`${url}?marketType=${marketType}&marketIndex=${marketIndex}`
-	);
-	return await response.json();
+	try {
+		const response = await fetch(
+			`${url}/batchPriorityFees?marketType=${marketTypes.join(
+				','
+			)}&marketIndex=${marketIndexs.join(',')}`
+		);
+		return await response.json();
+	} catch (err) {
+		console.error(err);
+	}
+
+	return [];
 }

package/src/priorityFee/heliusPriorityFeeMethod.ts

@@ -29,23 +29,29 @@ export async function fetchHeliusPriorityFee(
 	lookbackDistance: number,
 	addresses: string[]
 ): Promise<HeliusPriorityFeeResponse> {
-	const response = await fetch(heliusRpcUrl, {
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		body: JSON.stringify({
-			jsonrpc: '2.0',
-			id: '1',
-			method: 'getPriorityFeeEstimate',
-			params: [
-				{
-					accountKeys: addresses,
-					options: {
-						includeAllPriorityFeeLevels: true,
-						lookbackSlots: lookbackDistance,
+	try {
+		const response = await fetch(heliusRpcUrl, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				jsonrpc: '2.0',
+				id: '1',
+				method: 'getPriorityFeeEstimate',
+				params: [
+					{
+						accountKeys: addresses,
+						options: {
+							includeAllPriorityFeeLevels: true,
+							lookbackSlots: lookbackDistance,
+						},
 					},
-				},
-			],
-		}),
-	});
-	return await response.json();
+				],
+			}),
+		});
+		return await response.json();
+	} catch (err) {
+		console.error(err);
+	}
+
+	return undefined;
 }

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -13,7 +13,6 @@ import {
 	fetchHeliusPriorityFee,
 } from './heliusPriorityFeeMethod';
 import { fetchDriftPriorityFee } from './driftPriorityFeeMethod';
-import { getVariant, MarketType } from '..';
 
 export type DriftMarketInfo = {
 	marketType: string;
@@ -24,7 +23,7 @@ export class PriorityFeeSubscriber {
 	connection: Connection;
 	frequencyMs: number;
 	addresses: string[];
-	driftMarket?: DriftMarketInfo;
+	driftMarkets?: DriftMarketInfo[];
 	customStrategy?: PriorityFeeStrategy;
 	averageStrategy = new AverageOverSlotsStrategy();
 	maxStrategy = new MaxOverSlotsStrategy();
@@ -51,7 +50,7 @@ export class PriorityFeeSubscriber {
 		this.addresses = config.addresses
 			? config.addresses.map((address) => address.toBase58())
 			: [];
-		this.driftMarket = config.driftMarket;
+		this.driftMarkets = config.driftMarkets;
 
 		if (config.customStrategy) {
 			this.customStrategy = config.customStrategy;
@@ -107,13 +106,15 @@ export class PriorityFeeSubscriber {
 			this.lookbackDistance,
 			this.addresses
 		);
-		this.latestPriorityFee = samples[0].prioritizationFee;
-		this.lastSlotSeen = samples[0].slot;
+		if (samples.length > 0) {
+			this.latestPriorityFee = samples[0].prioritizationFee;
+			this.lastSlotSeen = samples[0].slot;
 
-		this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
-		this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
-		if (this.customStrategy) {
-			this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
+			this.lastAvgStrategyResult = this.averageStrategy.calculate(samples);
+			this.lastMaxStrategyResult = this.maxStrategy.calculate(samples);
+			if (this.customStrategy) {
+				this.lastCustomStrategyResult = this.customStrategy.calculate(samples);
+			}
 		}
 	}
 
@@ -137,26 +138,19 @@ export class PriorityFeeSubscriber {
 	}
 
 	private async loadForDrift(): Promise<void> {
-		if (!this.driftMarket) {
+		if (!this.driftMarkets) {
 			return;
 		}
 		const sample = await fetchDriftPriorityFee(
 			this.driftPriorityFeeEndpoint!,
-			this.driftMarket.marketType,
-			this.driftMarket.marketIndex
+			this.driftMarkets.map((m) => m.marketType),
+			this.driftMarkets.map((m) => m.marketIndex)
 		);
 		if (sample.length > 0) {
 			this.lastAvgStrategyResult = sample[HeliusPriorityLevel.MEDIUM];
 			this.lastMaxStrategyResult = sample[HeliusPriorityLevel.UNSAFE_MAX];
 			if (this.customStrategy) {
-				// stay compatible with helius response
-				this.lastCustomStrategyResult = this.customStrategy.calculate({
-					jsonrpc: '',
-					result: {
-						priorityFeeLevels: sample[0],
-					},
-					id: '',
-				});
+				this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
 			}
 		}
 	}
@@ -251,7 +245,7 @@ export class PriorityFeeSubscriber {
 		this.addresses = addresses.map((k) => k.toBase58());
 	}
 
-	public updateMarketTypeAndIndex(marketType: MarketType, marketIndex: number) {
-		this.driftMarket = { marketType: getVariant(marketType), marketIndex };
+	public updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]) {
+		this.driftMarkets = driftMarkets;
 	}
 }

package/src/priorityFee/solanaPriorityFeeMethod.ts

@@ -10,19 +10,25 @@ export async function fetchSolanaPriorityFee(
 	lookbackDistance: number,
 	addresses: string[]
 ): Promise<SolanaPriorityFeeResponse[]> {
-	// @ts-ignore
-	const rpcJSONResponse: any = await connection._rpcRequest(
-		'getRecentPrioritizationFees',
-		[addresses]
-	);
+	try {
+		// @ts-ignore
+		const rpcJSONResponse: any = await connection._rpcRequest(
+			'getRecentPrioritizationFees',
+			[addresses]
+		);
 
-	const results: SolanaPriorityFeeResponse[] = rpcJSONResponse?.result;
+		const results: SolanaPriorityFeeResponse[] = rpcJSONResponse?.result;
 
-	if (!results.length) return;
+		if (!results.length) return;
 
-	// Sort and filter results based on the slot lookback setting
-	const descResults = results.sort((a, b) => b.slot - a.slot);
-	const cutoffSlot = descResults[0].slot - lookbackDistance;
+		// Sort and filter results based on the slot lookback setting
+		const descResults = results.sort((a, b) => b.slot - a.slot);
+		const cutoffSlot = descResults[0].slot - lookbackDistance;
 
-	return descResults.filter((result) => result.slot >= cutoffSlot);
+		return descResults.filter((result) => result.slot >= cutoffSlot);
+	} catch (err) {
+		console.error(err);
+	}
+
+	return [];
 }

package/src/priorityFee/types.ts

@@ -2,12 +2,16 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
 import { DriftMarketInfo } from './priorityFeeSubscriber';
+import { DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
 
 export interface PriorityFeeStrategy {
 	// calculate the priority fee for a given set of samples.
 	// expect samples to be sorted in descending order (by slot)
 	calculate(
-		samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse
+		samples:
+			| SolanaPriorityFeeResponse[]
+			| HeliusPriorityFeeResponse
+			| DriftPriorityFeeResponse
 	): number;
 }
 
@@ -25,7 +29,7 @@ export type PriorityFeeSubscriberConfig = {
 	/// addresses you plan to write lock, used to determine priority fees
 	addresses?: PublicKey[];
 	/// drift market type and index, optionally provide at initialization time if using priorityFeeMethod.DRIFT
-	driftMarket?: DriftMarketInfo;
+	driftMarkets?: DriftMarketInfo[];
 	/// custom strategy to calculate priority fees, defaults to AVERAGE
 	customStrategy?: PriorityFeeStrategy;
 	/// method for fetching priority fee samples