@drift-labs/sdk 2.54.0-beta.6 → 2.54.0-beta.8

package/VERSION

@@ -1 +1 @@
-2.54.0-beta.6
+2.54.0-beta.8

package/lib/driftClient.d.ts

@@ -284,10 +284,11 @@ export declare class DriftClient {
      * @param cancelExistingOrders - Builds and returns an extra transaciton to cancel the existing orders in the same perp market. Intended use is to auto-cancel TP/SL orders when closing a position. Ignored if orderParams.marketType is not MarketType.PERP
      * @returns
      */
-    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean): Promise<{
+    sendMarketOrderAndGetSignedFillTx(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
         txSig: TransactionSignature;
         signedFillTx?: Transaction;
         signedCancelExistingOrdersTx?: Transaction;
+        signedSettlePnlTx?: Transaction;
     }>;
     placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
@@ -427,9 +428,10 @@ export declare class DriftClient {
     updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
     getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
-    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean): Promise<{
+    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
         txSig: TransactionSignature;
         signedCancelExistingOrdersTx?: Transaction;
+        signedSettlePnlTx?: Transaction;
     }>;
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;

package/lib/driftClient.js

@@ -1419,17 +1419,24 @@ class DriftClient {
      * @param cancelExistingOrders - Builds and returns an extra transaciton to cancel the existing orders in the same perp market. Intended use is to auto-cancel TP/SL orders when closing a position. Ignored if orderParams.marketType is not MarketType.PERP
      * @returns
      */
-    async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders) {
+    async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders, settlePnl) {
         const marketIndex = orderParams.marketIndex;
         const orderId = userAccount.nextOrderId;
         const ordersIx = await this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
-        let cancelOrdersIx;
+        /* Cancel open orders in market if requested */
         let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
-            cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
+            const cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
             //@ts-ignore
             cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
         }
+        /* Settle PnL after fill if requested */
+        let settlePnlTx;
+        if (settlePnl && (0, types_1.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(ordersIx, txParams, 0);
@@ -1438,11 +1445,21 @@ class DriftClient {
                 marketIndex,
             }, makerInfo, referrerInfo, userAccount.subAccountId);
             const versionedFillTx = await this.buildTransaction([fillPerpOrderIx], txParams, 0);
-            const [signedVersionedMarketOrderTx, signedVersionedFillTx, signedCancelExistingOrdersTx,] = await this.provider.wallet.signAllTransactions([
+            const allPossibleTxs = [
                 versionedMarketOrderTx,
                 versionedFillTx,
                 cancelExistingOrdersTx,
-            ].filter((tx) => tx !== undefined));
+                settlePnlTx,
+            ];
+            const txKeys = [
+                'signedVersionedMarketOrderTx',
+                'signedVersionedFillTx',
+                'signedCancelExistingOrdersTx',
+                'signedSettlePnlTx',
+            ];
+            const { signedVersionedMarketOrderTx, signedVersionedFillTx, signedCancelExistingOrdersTx, signedSettlePnlTx, } = await (0, utils_1.getSignedTransactionMap)(
+            //@ts-ignore
+            this.provider.wallet, allPossibleTxs, txKeys);
             const { txSig, slot } = await this.txSender.sendRawTransaction(signedVersionedMarketOrderTx.serialize(), this.opts);
             this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
             return {
@@ -1451,6 +1468,8 @@ class DriftClient {
                 signedFillTx: signedVersionedFillTx,
                 // @ts-ignore
                 signedCancelExistingOrdersTx,
+                // @ts-ignore
+                signedSettlePnlTx,
             };
         }
         else {
@@ -1463,10 +1482,33 @@ class DriftClient {
                 cancelExistingOrdersTx.recentBlockhash = currentBlockHash;
                 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 (0, utils_1.getSignedTransactionMap)(
+            //@ts-ignore
+            this.provider.wallet, allPossibleTxs, txKeys);
             const { txSig, slot } = await this.sendTransaction(signedMarketOrderTx, [], this.opts, true);
             this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
-            return { txSig, signedFillTx: undefined, signedCancelExistingOrdersTx };
+            return {
+                txSig,
+                signedFillTx: undefined,
+                //@ts-ignore
+                signedCancelExistingOrdersTx,
+                //@ts-ignore
+                signedSettlePnlTx,
+            };
         }
     }
     async placePerpOrder(orderParams, txParams, subAccountId) {
@@ -2404,13 +2446,20 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders) {
-        let signedCancelExistingOrdersTx;
+    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl) {
+        let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
             const cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, subAccountId);
-            const cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
-            // @ts-ignore
-            signedCancelExistingOrdersTx = await this.provider.wallet.signTransaction(cancelExistingOrdersTx);
+            //@ts-ignore
+            cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion);
+        }
+        /* Settle PnL after fill if requested */
+        let settlePnlTx;
+        if (settlePnl && (0, types_1.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);
@@ -2419,9 +2468,24 @@ class DriftClient {
             const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
             ixs.push(bracketOrdersIx);
         }
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(ixs, txParams), [], this.opts);
+        const placeAndTakeTx = await this.buildTransaction(ixs, txParams);
+        const allPossibleTxs = [
+            placeAndTakeTx,
+            cancelExistingOrdersTx,
+            settlePnlTx,
+        ];
+        const txKeys = [
+            'signedPlaceAndTakeTx',
+            'signedCancelExistingOrdersTx',
+            'signedSettlePnlTx',
+        ];
+        const { signedPlaceAndTakeTx, signedCancelExistingOrdersTx, signedSettlePnlTx, } = await (0, utils_1.getSignedTransactionMap)(
+        //@ts-ignore
+        this.provider.wallet, allPossibleTxs, txKeys);
+        const { txSig, slot } = await this.sendTransaction(signedPlaceAndTakeTx, [], this.opts, true);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
-        return { txSig, signedCancelExistingOrdersTx };
+        //@ts-ignore
+        return { txSig, signedCancelExistingOrdersTx, signedSettlePnlTx };
     }
     async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.PERP });

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/package.json

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

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,11 +2565,13 @@ 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;
@@ -2579,10 +2581,10 @@ export class DriftClient {
 			userAccount.subAccountId
 		);
 
-		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,
@@ -2597,6 +2599,23 @@ 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(
@@ -2623,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
@@ -2646,6 +2679,8 @@ export class DriftClient {
 				signedFillTx: signedVersionedFillTx,
 				// @ts-ignore
 				signedCancelExistingOrdersTx,
+				// @ts-ignore
+				signedSettlePnlTx,
 			};
 		} else {
 			const marketOrderTx = wrapInTx(
@@ -2667,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,
 				[],
@@ -2681,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,
+			};
 		}
 	}
 
@@ -4330,13 +4393,14 @@ export class DriftClient {
 		bracketOrdersParams = new Array<OptionalOrderParams>(),
 		txParams?: TxParams,
 		subAccountId?: number,
-		cancelExistingOrders?: boolean
+		cancelExistingOrders?: boolean,
+		settlePnl?: boolean
 	): Promise<{
 		txSig: TransactionSignature;
 		signedCancelExistingOrdersTx?: Transaction;
+		signedSettlePnlTx?: Transaction;
 	}> {
-		let signedCancelExistingOrdersTx: Transaction;
-
+		let cancelExistingOrdersTx: Transaction;
 		if (cancelExistingOrders && isVariant(orderParams.marketType, 'perp')) {
 			const cancelOrdersIx = await this.getCancelOrdersIx(
 				orderParams.marketType,
@@ -4345,15 +4409,32 @@ export class DriftClient {
 				subAccountId
 			);
 
-			const cancelExistingOrdersTx = await this.buildTransaction(
+			//@ts-ignore
+			cancelExistingOrdersTx = await this.buildTransaction(
 				[cancelOrdersIx],
 				txParams,
 				this.txVersion
 			);
+		}
 
-			// @ts-ignore
-			signedCancelExistingOrdersTx = await this.provider.wallet.signTransaction(
-				cancelExistingOrdersTx
+		/* 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
 			);
 		}
 
@@ -4376,14 +4457,40 @@ export class DriftClient {
 			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(
-			await this.buildTransaction(ixs, txParams),
+			signedPlaceAndTakeTx,
 			[],
-			this.opts
+			this.opts,
+			true
 		);
 		this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
 
-		return { txSig, signedCancelExistingOrdersTx };
+		//@ts-ignore
+		return { txSig, signedCancelExistingOrdersTx, signedSettlePnlTx };
 	}
 
 	public async getPlaceAndTakePerpOrderIx(

package/src/tx/retryTxSender.ts

@@ -1,9 +1,5 @@
 import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import {
-	ConfirmOptions,
-	TransactionSignature,
-	Connection,
-} from '@solana/web3.js';
+import { ConfirmOptions, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { IWallet } from '../types';
 import { BaseTxSender } from './baseTxSender';
@@ -70,14 +66,8 @@ export class RetryTxSender extends BaseTxSender {
 	): Promise<TxSigAndSlot> {
 		const startTime = this.getTimestamp();
 
-		let txid: TransactionSignature;
-		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: ResolveReference = {
@@ -105,16 +95,8 @@ export class RetryTxSender extends BaseTxSender {
 			}
 		})();
 
-		let slot: number;
-		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/src/tx/utils.ts

@@ -1,7 +1,9 @@
+import { Wallet } from '@coral-xyz/anchor';
 import {
 	Transaction,
 	TransactionInstruction,
 	ComputeBudgetProgram,
+	VersionedTransaction,
 } from '@solana/web3.js';
 
 const COMPUTE_UNITS_DEFAULT = 200_000;
@@ -30,3 +32,33 @@ export function wrapInTx(
 
 	return tx.add(instruction);
 }
+
+/* Helper function for signing multiple transactions where some may be undefined and mapping the output */
+export async function getSignedTransactionMap(
+	wallet: Wallet,
+	txsToSign: (Transaction | VersionedTransaction | undefined)[],
+	keys: string[]
+): Promise<{ [key: string]: Transaction | VersionedTransaction | undefined }> {
+	const signedTxMap: {
+		[key: string]: Transaction | VersionedTransaction | undefined;
+	} = {};
+
+	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;
+}