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

package/lib/tx/baseTxSender.js

@@ -158,14 +158,14 @@ class BaseTxSender {
     async confirmTransactionPolling(signature, commitment = 'finalized') {
         var _a;
         let totalTime = 0;
-        let backoffTime = 250;
+        let backoffTime = 400; // approx block time
         while (totalTime < this.timeout) {
+            await new Promise((resolve) => setTimeout(resolve, backoffTime));
             const response = await this.connection.getSignatureStatus(signature);
             const result = response && ((_a = response.value) === null || _a === void 0 ? void 0 : _a[0]);
             if (result && result.confirmationStatus === commitment) {
                 return { context: result.context, value: { err: null } };
             }
-            await new Promise((resolve) => setTimeout(resolve, backoffTime));
             totalTime += backoffTime;
             backoffTime = Math.min(backoffTime * 2, 5000);
         }

package/lib/tx/retryTxSender.js

@@ -32,15 +32,8 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
     }
     async sendRawTransaction(rawTransaction, opts) {
         const startTime = this.getTimestamp();
-        let txid;
-        try {
-            txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-            this.sendToAdditionalConnections(rawTransaction, opts);
-        }
-        catch (e) {
-            console.error(e);
-            throw e;
-        }
+        const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+        this.sendToAdditionalConnections(rawTransaction, opts);
         let done = false;
         const resolveReference = {
             resolve: undefined,
@@ -65,18 +58,8 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
                 }
             }
         })();
-        let slot;
-        try {
-            const result = await this.confirmTransaction(txid, opts.commitment);
-            slot = result.context.slot;
-        }
-        catch (e) {
-            console.error(e);
-            throw e;
-        }
-        finally {
-            stopWaiting();
-        }
+        const result = await this.confirmTransaction(txid, opts.commitment);
+        const slot = result.context.slot;
         return { txSig: txid, slot };
     }
 }

package/lib/tx/utils.d.ts

@@ -1,2 +1,6 @@
-import { Transaction, TransactionInstruction } from '@solana/web3.js';
+import { Wallet } from '@coral-xyz/anchor';
+import { Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 export declare function wrapInTx(instruction: TransactionInstruction, computeUnits?: number, computeUnitsPrice?: number): Transaction;
+export declare function getSignedTransactionMap(wallet: Wallet, txsToSign: (Transaction | VersionedTransaction | undefined)[], keys: string[]): Promise<{
+    [key: string]: Transaction | VersionedTransaction | undefined;
+}>;

package/lib/tx/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapInTx = void 0;
+exports.getSignedTransactionMap = exports.wrapInTx = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const COMPUTE_UNITS_DEFAULT = 200000;
 function wrapInTx(instruction, computeUnits = 600000, computeUnitsPrice = 0) {
@@ -18,3 +18,22 @@ function wrapInTx(instruction, computeUnits = 600000, computeUnitsPrice = 0) {
     return tx.add(instruction);
 }
 exports.wrapInTx = wrapInTx;
+/* Helper function for signing multiple transactions where some may be undefined and mapping the output */
+async function getSignedTransactionMap(wallet, txsToSign, keys) {
+    const signedTxMap = {};
+    const keysWithTx = [];
+    txsToSign.forEach((tx, index) => {
+        if (tx == undefined) {
+            signedTxMap[keys[index]] = undefined;
+        }
+        else {
+            keysWithTx.push(keys[index]);
+        }
+    });
+    const signedTxs = await wallet.signAllTransactions(txsToSign.filter((tx) => tx !== undefined));
+    signedTxs.forEach((signedTx, index) => {
+        signedTxMap[keysWithTx[index]] = signedTx;
+    });
+    return signedTxMap;
+}
+exports.getSignedTransactionMap = getSignedTransactionMap;

package/lib/userMap/userMap.js

@@ -236,6 +236,10 @@ class UserMap {
                     await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
                     this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
                 }
+                else {
+                    const userAccount = this.decode('User', buffer);
+                    this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
+                }
                 // give event loop a chance to breathe
                 await new Promise((resolve) => setTimeout(resolve, 0));
             }

package/package.json

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

package/src/accounts/pollingInsuranceFundStakeAccountSubscriber.ts

@@ -54,7 +54,6 @@ export class PollingInsuranceFundStakeAccountSubscriber
 
 		await this.addToAccountLoader();
 
-		await this.fetchIfUnloaded();
 		if (this.doesAccountExist()) {
 			this.eventEmitter.emit('update');
 		}

package/src/constants/perpMarkets.ts

@@ -234,6 +234,16 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1703173331000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'AVAX',
+		category: ['Rollup', 'Infra'],
+		symbol: 'AVAX-PERP',
+		baseAssetSymbol: 'AVAX',
+		marketIndex: 22,
+		oracle: new PublicKey('FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz'),
+		launchTs: 1704209558000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const MainnetPerpMarkets: PerpMarketConfig[] = [
@@ -457,6 +467,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1703173331000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'AVAX',
+		category: ['Rollup', 'Infra'],
+		symbol: 'AVAX-PERP',
+		baseAssetSymbol: 'AVAX',
+		marketIndex: 22,
+		oracle: new PublicKey('Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU'),
+		launchTs: 1704209558000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/driftClient.ts

@@ -88,7 +88,7 @@ import {
 	DataAndSlot,
 } from './accounts/types';
 import { TxSender, TxSigAndSlot } from './tx/types';
-import { wrapInTx } from './tx/utils';
+import { getSignedTransactionMap, wrapInTx } from './tx/utils';
 import {
 	BASE_PRECISION,
 	PRICE_PRECISION,
@@ -2565,33 +2565,26 @@ export class DriftClient {
 		txParams?: TxParams,
 		bracketOrdersParams = new Array<OptionalOrderParams>(),
 		referrerInfo?: ReferrerInfo,
-		cancelExistingOrders?: boolean
+		cancelExistingOrders?: boolean,
+		settlePnl?: boolean
 	): Promise<{
 		txSig: TransactionSignature;
 		signedFillTx?: Transaction;
 		signedCancelExistingOrdersTx?: Transaction;
+		signedSettlePnlTx?: Transaction;
 	}> {
 		const marketIndex = orderParams.marketIndex;
 		const orderId = userAccount.nextOrderId;
-		const bracketOrderIxs = [];
 
-		const placePerpOrderIx = await this.getPlacePerpOrderIx(
-			orderParams,
+		const ordersIx = await this.getPlaceOrdersIx(
+			[orderParams, ...bracketOrdersParams],
 			userAccount.subAccountId
 		);
 
-		for (const bracketOrderParams of bracketOrdersParams) {
-			const placeBracketOrderIx = await this.getPlacePerpOrderIx(
-				bracketOrderParams,
-				userAccount.subAccountId
-			);
-			bracketOrderIxs.push(placeBracketOrderIx);
-		}
-
-		let cancelOrdersIx: TransactionInstruction;
-		let cancelExistingOrdersTx: Transaction;
+		/* Cancel open orders in market if requested */
+		let cancelExistingOrdersTx;
 		if (cancelExistingOrders && isVariant(orderParams.marketType, 'perp')) {
-			cancelOrdersIx = await this.getCancelOrdersIx(
+			const cancelOrdersIx = await this.getCancelOrdersIx(
 				orderParams.marketType,
 				orderParams.marketIndex,
 				null,
@@ -2606,10 +2599,27 @@ export class DriftClient {
 			);
 		}
 
+		/* Settle PnL after fill if requested */
+		let settlePnlTx;
+		if (settlePnl && isVariant(orderParams.marketType, 'perp')) {
+			const settlePnlIx = await this.settlePNLIx(
+				userAccountPublicKey,
+				userAccount,
+				marketIndex
+			);
+
+			//@ts-ignore
+			settlePnlTx = await this.buildTransaction(
+				[settlePnlIx],
+				txParams,
+				this.txVersion
+			);
+		}
+
 		// use versioned transactions if there is a lookup table account and wallet is compatible
 		if (this.txVersion === 0) {
 			const versionedMarketOrderTx = await this.buildTransaction(
-				[placePerpOrderIx].concat(bracketOrderIxs),
+				ordersIx,
 				txParams,
 				0
 			);
@@ -2632,17 +2642,31 @@ export class DriftClient {
 				0
 			);
 
-			const [
+			const allPossibleTxs = [
+				versionedMarketOrderTx,
+				versionedFillTx,
+				cancelExistingOrdersTx,
+				settlePnlTx,
+			];
+			const txKeys = [
+				'signedVersionedMarketOrderTx',
+				'signedVersionedFillTx',
+				'signedCancelExistingOrdersTx',
+				'signedSettlePnlTx',
+			];
+
+			const {
 				signedVersionedMarketOrderTx,
 				signedVersionedFillTx,
 				signedCancelExistingOrdersTx,
-			] = await this.provider.wallet.signAllTransactions(
-				[
-					versionedMarketOrderTx,
-					versionedFillTx,
-					cancelExistingOrdersTx,
-				].filter((tx) => tx !== undefined)
+				signedSettlePnlTx,
+			} = await getSignedTransactionMap(
+				//@ts-ignore
+				this.provider.wallet,
+				allPossibleTxs,
+				txKeys
 			);
+
 			const { txSig, slot } = await this.txSender.sendRawTransaction(
 				signedVersionedMarketOrderTx.serialize(),
 				this.opts
@@ -2655,18 +2679,16 @@ export class DriftClient {
 				signedFillTx: signedVersionedFillTx,
 				// @ts-ignore
 				signedCancelExistingOrdersTx,
+				// @ts-ignore
+				signedSettlePnlTx,
 			};
 		} else {
 			const marketOrderTx = wrapInTx(
-				placePerpOrderIx,
+				ordersIx,
 				txParams?.computeUnits,
 				txParams?.computeUnitsPrice
 			);
 
-			if (bracketOrderIxs.length > 0) {
-				marketOrderTx.add(...bracketOrderIxs);
-			}
-
 			// Apply the latest blockhash to the txs so that we can sign before sending them
 			const currentBlockHash = (
 				await this.connection.getLatestBlockhash('finalized')
@@ -2680,12 +2702,33 @@ export class DriftClient {
 				cancelExistingOrdersTx.feePayer = userAccount.authority;
 			}
 
-			const [signedMarketOrderTx, signedCancelExistingOrdersTx] =
-				await this.provider.wallet.signAllTransactions(
-					[marketOrderTx, cancelExistingOrdersTx].filter(
-						(tx) => tx !== undefined
-					)
-				);
+			if (settlePnlTx) {
+				settlePnlTx.recentBlockhash = currentBlockHash;
+				settlePnlTx.feePayer = userAccount.authority;
+			}
+
+			const allPossibleTxs = [
+				marketOrderTx,
+				cancelExistingOrdersTx,
+				settlePnlTx,
+			];
+			const txKeys = [
+				'signedMarketOrderTx',
+				'signedCancelExistingOrdersTx',
+				'signedSettlePnlTx',
+			];
+
+			const {
+				signedMarketOrderTx,
+				signedCancelExistingOrdersTx,
+				signedSettlePnlTx,
+			} = await getSignedTransactionMap(
+				//@ts-ignore
+				this.provider.wallet,
+				allPossibleTxs,
+				txKeys
+			);
+
 			const { txSig, slot } = await this.sendTransaction(
 				signedMarketOrderTx,
 				[],
@@ -2694,7 +2737,14 @@ export class DriftClient {
 			);
 			this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
 
-			return { txSig, signedFillTx: undefined, signedCancelExistingOrdersTx };
+			return {
+				txSig,
+				signedFillTx: undefined,
+				//@ts-ignore
+				signedCancelExistingOrdersTx,
+				//@ts-ignore
+				signedSettlePnlTx,
+			};
 		}
 	}
 
@@ -3093,7 +3143,7 @@ export class DriftClient {
 	}
 
 	public async getPlaceOrdersIx(
-		params: OrderParams[],
+		params: OptionalOrderParams[],
 		subAccountId?: number
 	): Promise<TransactionInstruction> {
 		const user = await this.getUserAccountPublicKey(subAccountId);
@@ -3118,7 +3168,9 @@ export class DriftClient {
 			useMarketLastSlotCache: true,
 		});
 
-		return await this.program.instruction.placeOrders(params, {
+		const formattedParams = params.map((item) => getOrderParams(item));
+
+		return await this.program.instruction.placeOrders(formattedParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user,
@@ -3868,7 +3920,6 @@ export class DriftClient {
 				slippageBps,
 				swapMode,
 				onlyDirectRoutes,
-				excludeDexes: ['Raydium CLMM'], // temp exclude to workaround bug with raydium clmm
 			});
 
 			quote = fetchedQuote;
@@ -4335,6 +4386,113 @@ export class DriftClient {
 		return txSig;
 	}
 
+	public async placeAndTakePerpWithAdditionalOrders(
+		orderParams: OptionalOrderParams,
+		makerInfo?: MakerInfo | MakerInfo[],
+		referrerInfo?: ReferrerInfo,
+		bracketOrdersParams = new Array<OptionalOrderParams>(),
+		txParams?: TxParams,
+		subAccountId?: number,
+		cancelExistingOrders?: boolean,
+		settlePnl?: boolean
+	): Promise<{
+		txSig: TransactionSignature;
+		signedCancelExistingOrdersTx?: Transaction;
+		signedSettlePnlTx?: Transaction;
+	}> {
+		let cancelExistingOrdersTx: Transaction;
+		if (cancelExistingOrders && isVariant(orderParams.marketType, 'perp')) {
+			const cancelOrdersIx = await this.getCancelOrdersIx(
+				orderParams.marketType,
+				orderParams.marketIndex,
+				null,
+				subAccountId
+			);
+
+			//@ts-ignore
+			cancelExistingOrdersTx = await this.buildTransaction(
+				[cancelOrdersIx],
+				txParams,
+				this.txVersion
+			);
+		}
+
+		/* Settle PnL after fill if requested */
+		let settlePnlTx: Transaction;
+		if (settlePnl && isVariant(orderParams.marketType, 'perp')) {
+			const userAccountPublicKey = await this.getUserAccountPublicKey(
+				subAccountId
+			);
+
+			const settlePnlIx = await this.settlePNLIx(
+				userAccountPublicKey,
+				this.getUserAccount(subAccountId),
+				orderParams.marketIndex
+			);
+
+			//@ts-ignore
+			settlePnlTx = await this.buildTransaction(
+				[settlePnlIx],
+				txParams,
+				this.txVersion
+			);
+		}
+
+		const ixs = [];
+
+		const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(
+			orderParams,
+			makerInfo,
+			referrerInfo,
+			subAccountId
+		);
+
+		ixs.push(placeAndTakeIx);
+
+		if (bracketOrdersParams.length > 0) {
+			const bracketOrdersIx = await this.getPlaceOrdersIx(
+				bracketOrdersParams,
+				subAccountId
+			);
+			ixs.push(bracketOrdersIx);
+		}
+
+		const placeAndTakeTx = await this.buildTransaction(ixs, txParams);
+
+		const allPossibleTxs = [
+			placeAndTakeTx,
+			cancelExistingOrdersTx,
+			settlePnlTx,
+		];
+		const txKeys = [
+			'signedPlaceAndTakeTx',
+			'signedCancelExistingOrdersTx',
+			'signedSettlePnlTx',
+		];
+
+		const {
+			signedPlaceAndTakeTx,
+			signedCancelExistingOrdersTx,
+			signedSettlePnlTx,
+		} = await getSignedTransactionMap(
+			//@ts-ignore
+			this.provider.wallet,
+			allPossibleTxs,
+			txKeys
+		);
+
+		const { txSig, slot } = await this.sendTransaction(
+			signedPlaceAndTakeTx,
+			[],
+			this.opts,
+			true
+		);
+		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
+
+		//@ts-ignore
+		return { txSig, signedCancelExistingOrdersTx, signedSettlePnlTx };
+	}
+
 	public async getPlaceAndTakePerpOrderIx(
 		orderParams: OptionalOrderParams,
 		makerInfo?: MakerInfo | MakerInfo[],

package/src/events/webSocketLogProvider.ts

@@ -1,5 +1,11 @@
 import { LogProvider, logProviderCallback } from './types';
-import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import {
+	Commitment,
+	Connection,
+	Context,
+	Logs,
+	PublicKey,
+} from '@solana/web3.js';
 import { EventEmitter } from 'events';
 
 export class WebSocketLogProvider implements LogProvider {
@@ -45,7 +51,7 @@ export class WebSocketLogProvider implements LogProvider {
 	public setSubscription(callback: logProviderCallback): void {
 		this.subscriptionId = this.connection.onLogs(
 			this.address,
-			(logs, ctx) => {
+			(logs: Logs, ctx: Context) => {
 				if (this.resubTimeoutMs && !this.isUnsubscribing) {
 					this.receivingData = true;
 					clearTimeout(this.timeoutId);
@@ -55,6 +61,9 @@ export class WebSocketLogProvider implements LogProvider {
 					}
 					this.reconnectAttempts = 0;
 				}
+				if (logs.err !== null) {
+					return;
+				}
 				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},
 			this.commitment

package/src/idl/drift.json

@@ -8524,7 +8524,13 @@
         "kind": "enum",
         "variants": [
           {
-            "name": "Standard"
+            "name": "Standard",
+            "fields": [
+              {
+                "name": "track_open_orders_fraction",
+                "type": "bool"
+              }
+            ]
           },
           {
             "name": "Liquidation",

package/src/jupiter/jupiterClient.ts

@@ -210,6 +210,12 @@ export interface QuoteResponse {
 	 * @memberof QuoteResponse
 	 */
 	timeTaken?: number;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	error?: string;
 }
 
 export class JupiterClient {
@@ -279,7 +285,7 @@ export class JupiterClient {
 		slippageBps = 50,
 		swapMode = 'ExactIn',
 		onlyDirectRoutes = false,
-		excludeDexes = [],
+		excludeDexes,
 	}: {
 		inputMint: PublicKey;
 		outputMint: PublicKey;
@@ -298,7 +304,7 @@ export class JupiterClient {
 			swapMode,
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
 			maxAccounts: maxAccounts.toString(),
-			excludeDexes: excludeDexes.join(','),
+			...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
 		}).toString();
 		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
 		return quote;

package/src/math/funding.ts

@@ -11,6 +11,7 @@ import { PerpMarketAccount, isVariant } from '../types';
 import { OraclePriceData } from '../oracles/types';
 import { calculateBidAskPrice } from './amm';
 import { calculateLiveOracleTwap } from './oracles';
+import { clampBN } from './utils';
 
 function calculateLiveMarkTwap(
 	market: PerpMarketAccount,
@@ -160,8 +161,15 @@ export async function calculateAllEstimatedFundingRate(
 	const twapSpreadWithOffset = twapSpread.add(
 		oracleTwap.abs().div(FUNDING_RATE_OFFSET_DENOMINATOR)
 	);
+	const maxSpread = getMaxPriceDivergenceForFundingRate(market, oracleTwap);
 
-	const twapSpreadPct = twapSpreadWithOffset
+	const clampedSpreadWithOffset = clampBN(
+		twapSpreadWithOffset,
+		maxSpread.mul(new BN(-1)),
+		maxSpread
+	);
+
+	const twapSpreadPct = clampedSpreadWithOffset
 		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
 		.div(oracleTwap);
@@ -234,6 +242,25 @@ export async function calculateAllEstimatedFundingRate(
 	return [markTwap, oracleTwap, lowerboundEst, cappedAltEst, interpEst];
 }
 
+function getMaxPriceDivergenceForFundingRate(
+	market: PerpMarketAccount,
+	oracleTwap: BN
+) {
+	if (isVariant(market.contractTier, 'a')) {
+		return oracleTwap.divn(33);
+	} else if (isVariant(market.contractTier, 'b')) {
+		return oracleTwap.divn(33);
+	} else if (isVariant(market.contractTier, 'c')) {
+		return oracleTwap.divn(20);
+	} else if (isVariant(market.contractTier, 'speculative')) {
+		return oracleTwap.divn(10);
+	} else if (isVariant(market.contractTier, 'isolated')) {
+		return oracleTwap.divn(10);
+	} else {
+		return oracleTwap.divn(10);
+	}
+}
+
 /**
  *
  * @param market

package/src/math/oracles.ts

@@ -47,8 +47,8 @@ export function isOracleValid(
 		.div(oraclePriceData.price)
 		.gt(oracleGuardRails.validity.confidenceIntervalMaxSize);
 
-	const oracleIsStale = oraclePriceData.slot
-		.sub(new BN(slot))
+	const oracleIsStale = new BN(slot)
+		.sub(oraclePriceData.slot)
 		.gt(oracleGuardRails.validity.slotsBeforeStaleForAmm);
 
 	return !(