@drift-labs/sdk 2.55.0-beta.4 → 2.56.0-beta.1

package/VERSION

@@ -1 +1 @@
-2.55.0-beta.4
+2.56.0-beta.1

package/lib/driftClient.js

@@ -1470,7 +1470,7 @@ class DriftClient {
             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);
+            const { txSig, slot } = await this.sendTransaction(signedVersionedMarketOrderTx, [], this.opts, true);
             this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
             return {
                 txSig,

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.54.0",
+    "version": "2.55.0",
     "name": "drift",
     "instructions": [
         {

package/lib/math/position.d.ts

@@ -47,7 +47,7 @@ export declare function calculateEntryPrice(userPosition: PerpPosition): BN;
  * @param userPosition
  * @returns Precision: PRICE_PRECISION (10^10)
  */
-export declare function calculateCostBasis(userPosition: PerpPosition): BN;
+export declare function calculateCostBasis(userPosition: PerpPosition, includeSettledPnl?: boolean): BN;
 export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;
 export declare function positionCurrentDirection(userPosition: PerpPosition): PositionDirection;
 export declare function isEmptyPosition(userPosition: PerpPosition): boolean;

package/lib/math/position.js

@@ -162,11 +162,12 @@ exports.calculateEntryPrice = calculateEntryPrice;
  * @param userPosition
  * @returns Precision: PRICE_PRECISION (10^10)
  */
-function calculateCostBasis(userPosition) {
+function calculateCostBasis(userPosition, includeSettledPnl = false) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     return userPosition.quoteAssetAmount
+        .add(includeSettledPnl ? userPosition.settledPnl : numericConstants_1.ZERO)
         .mul(numericConstants_1.PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -34,24 +34,30 @@ class PriorityFeeSubscriber {
         this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
     }
     async load() {
-        // @ts-ignore
-        const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
-        const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
-        if (!results.length)
+        try {
+            // @ts-ignore
+            const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
+            const results = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result;
+            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 mostRecentResult = descResults[0];
+            const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+            const resultsToUse = descResults.filter((result) => result.slot >= cutoffSlot);
+            // # Handle results
+            this.latestPriorityFee = mostRecentResult.prioritizationFee;
+            this.lastSlotSeen = mostRecentResult.slot;
+            this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
+            this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
+            if (this.customStrategy) {
+                this.lastCustomStrategyResult =
+                    this.customStrategy.calculate(resultsToUse);
+            }
+        }
+        catch (err) {
+            // It's possible to get here with "TypeError: failed to fetch"
             return;
-        // # Sort and filter results based on the slot lookback setting
-        const descResults = results.sort((a, b) => b.slot - a.slot);
-        const mostRecentResult = descResults[0];
-        const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
-        const resultsToUse = descResults.filter((result) => result.slot >= cutoffSlot);
-        // # Handle results
-        this.latestPriorityFee = mostRecentResult.prioritizationFee;
-        this.lastSlotSeen = mostRecentResult.slot;
-        this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
-        this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
-        if (this.customStrategy) {
-            this.lastCustomStrategyResult =
-                this.customStrategy.calculate(resultsToUse);
         }
     }
     async unsubscribe() {

package/lib/tx/baseTxSender.d.ts

@@ -10,13 +10,15 @@ export declare abstract class BaseTxSender implements TxSender {
     additionalConnections: Connection[];
     timeoutCount: number;
     confirmationStrategy: ConfirmationStrategy;
-    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, }: {
+    additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
         timeout?: number;
         additionalConnections?: any;
         confirmationStrategy?: ConfirmationStrategy;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
     });
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;

package/lib/tx/baseTxSender.js

@@ -11,7 +11,7 @@ const assert_1 = __importDefault(require("assert"));
 const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_TIMEOUT = 35000;
 class BaseTxSender {
-    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, }) {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks, }) {
         this.timeoutCount = 0;
         this.connection = connection;
         this.wallet = wallet;
@@ -19,6 +19,7 @@ class BaseTxSender {
         this.timeout = timeout;
         this.additionalConnections = additionalConnections;
         this.confirmationStrategy = confirmationStrategy;
+        this.additionalTxSenderCallbacks = additionalTxSenderCallbacks;
     }
     async send(tx, additionalSigners, opts, preSigned, extraConfirmationOptions) {
         if (additionalSigners === undefined) {
@@ -202,6 +203,7 @@ class BaseTxSender {
         });
     }
     sendToAdditionalConnections(rawTx, opts) {
+        var _a;
         this.additionalConnections.map((connection) => {
             connection.sendRawTransaction(rawTx, opts).catch((e) => {
                 console.error(
@@ -210,6 +212,9 @@ class BaseTxSender {
                 console.error(e);
             });
         });
+        (_a = this.additionalTxSenderCallbacks) === null || _a === void 0 ? void 0 : _a.map((callback) => {
+            callback(bs58_1.default.encode(rawTx));
+        });
     }
     addAdditionalConnection(newConnection) {
         const alreadyUsingConnection = this.additionalConnections.filter((connection) => {

package/lib/tx/retryTxSender.d.ts

@@ -14,7 +14,7 @@ export declare class RetryTxSender extends BaseTxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, confirmationStrategy, }: {
+    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -22,6 +22,7 @@ export declare class RetryTxSender extends BaseTxSender {
         retrySleep?: number;
         additionalConnections?: any;
         confirmationStrategy?: ConfirmationStrategy;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
     });
     sleep(reference: ResolveReference): Promise<void>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;

package/lib/tx/retryTxSender.js

@@ -7,7 +7,7 @@ const baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
 class RetryTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, }) {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], }) {
         super({
             connection,
             wallet,
@@ -15,6 +15,7 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
             timeout,
             additionalConnections,
             confirmationStrategy,
+            additionalTxSenderCallbacks,
         });
         this.timoutCount = 0;
         this.connection = connection;

package/lib/user.js

@@ -1825,10 +1825,11 @@ class User {
             perpPnl: [],
         };
         for (const perpPosition of this.getActivePerpPositions()) {
+            const settledLpPosition = this.getPerpPositionWithLPSettle(perpPosition.marketIndex, perpPosition)[0];
             const perpMarket = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
             const oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(perpMarket.amm.oracle).data;
             const oraclePrice = oraclePriceData.price;
-            const worstCaseBaseAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
+            const worstCaseBaseAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(settledLpPosition);
             const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory, this.getUserAccount().maxMarginRatio));
             const quoteSpotMarket = this.driftClient.getSpotMarketAccount(perpMarket.quoteSpotMarketIndex);
             const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;

package/package.json

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

package/src/driftClient.ts

@@ -2690,9 +2690,11 @@ export class DriftClient {
 				txKeys
 			);
 
-			const { txSig, slot } = await this.txSender.sendRawTransaction(
-				signedVersionedMarketOrderTx.serialize(),
-				this.opts
+			const { txSig, slot } = await this.sendTransaction(
+				signedVersionedMarketOrderTx,
+				[],
+				this.opts,
+				true
 			);
 			this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
 

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.54.0",
+  "version": "2.55.0",
   "name": "drift",
   "instructions": [
     {

package/src/math/position.ts

@@ -237,12 +237,16 @@ export function calculateEntryPrice(userPosition: PerpPosition): BN {
  * @param userPosition
  * @returns Precision: PRICE_PRECISION (10^10)
  */
-export function calculateCostBasis(userPosition: PerpPosition): BN {
+export function calculateCostBasis(
+	userPosition: PerpPosition,
+	includeSettledPnl = false
+): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	return userPosition.quoteAssetAmount
+		.add(includeSettledPnl ? userPosition.settledPnl : ZERO)
 		.mul(PRICE_PRECISION)
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
 		.div(userPosition.baseAssetAmount)

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -57,35 +57,40 @@ export class PriorityFeeSubscriber {
 	}
 
 	public async load(): Promise<void> {
-		// @ts-ignore
-		const rpcJSONResponse: any = await this.connection._rpcRequest(
-			'getRecentPrioritizationFees',
-			[this.addresses]
-		);
+		try {
+			// @ts-ignore
+			const rpcJSONResponse: any = await this.connection._rpcRequest(
+				'getRecentPrioritizationFees',
+				[this.addresses]
+			);
 
-		const results: { slot: number; prioritizationFee: number }[] =
-			rpcJSONResponse?.result;
+			const results: { slot: number; prioritizationFee: number }[] =
+				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 mostRecentResult = descResults[0];
-		const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+			// # Sort and filter results based on the slot lookback setting
+			const descResults = results.sort((a, b) => b.slot - a.slot);
+			const mostRecentResult = descResults[0];
+			const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
 
-		const resultsToUse = descResults.filter(
-			(result) => result.slot >= cutoffSlot
-		);
+			const resultsToUse = descResults.filter(
+				(result) => result.slot >= cutoffSlot
+			);
 
-		// # Handle results
-		this.latestPriorityFee = mostRecentResult.prioritizationFee;
-		this.lastSlotSeen = mostRecentResult.slot;
+			// # Handle results
+			this.latestPriorityFee = mostRecentResult.prioritizationFee;
+			this.lastSlotSeen = mostRecentResult.slot;
 
-		this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
-		this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
-		if (this.customStrategy) {
-			this.lastCustomStrategyResult =
-				this.customStrategy.calculate(resultsToUse);
+			this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
+			this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
+			if (this.customStrategy) {
+				this.lastCustomStrategyResult =
+					this.customStrategy.calculate(resultsToUse);
+			}
+		} catch (err) {
+			// It's possible to get here with "TypeError: failed to fetch"
+			return;
 		}
 	}
 

package/src/tx/baseTxSender.ts

@@ -34,6 +34,7 @@ export abstract class BaseTxSender implements TxSender {
 	additionalConnections: Connection[];
 	timeoutCount = 0;
 	confirmationStrategy: ConfirmationStrategy;
+	additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
 
 	public constructor({
 		connection,
@@ -42,6 +43,7 @@ export abstract class BaseTxSender implements TxSender {
 		timeout = DEFAULT_TIMEOUT,
 		additionalConnections = new Array<Connection>(),
 		confirmationStrategy = ConfirmationStrategy.Combo,
+		additionalTxSenderCallbacks,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -49,6 +51,7 @@ export abstract class BaseTxSender implements TxSender {
 		timeout?: number;
 		additionalConnections?;
 		confirmationStrategy?: ConfirmationStrategy;
+		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 	}) {
 		this.connection = connection;
 		this.wallet = wallet;
@@ -56,6 +59,7 @@ export abstract class BaseTxSender implements TxSender {
 		this.timeout = timeout;
 		this.additionalConnections = additionalConnections;
 		this.confirmationStrategy = confirmationStrategy;
+		this.additionalTxSenderCallbacks = additionalTxSenderCallbacks;
 	}
 
 	async send(
@@ -333,6 +337,9 @@ export abstract class BaseTxSender implements TxSender {
 				console.error(e);
 			});
 		});
+		this.additionalTxSenderCallbacks?.map((callback) => {
+			callback(bs58.encode(rawTx));
+		});
 	}
 
 	public addAdditionalConnection(newConnection: Connection): void {

package/src/tx/retryTxSender.ts

@@ -28,6 +28,7 @@ export class RetryTxSender extends BaseTxSender {
 		retrySleep = DEFAULT_RETRY,
 		additionalConnections = new Array<Connection>(),
 		confirmationStrategy = ConfirmationStrategy.Combo,
+		additionalTxSenderCallbacks = [],
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -36,6 +37,7 @@ export class RetryTxSender extends BaseTxSender {
 		retrySleep?: number;
 		additionalConnections?;
 		confirmationStrategy?: ConfirmationStrategy;
+		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 	}) {
 		super({
 			connection,
@@ -44,6 +46,7 @@ export class RetryTxSender extends BaseTxSender {
 			timeout,
 			additionalConnections,
 			confirmationStrategy,
+			additionalTxSenderCallbacks,
 		});
 		this.connection = connection;
 		this.wallet = wallet;

package/src/user.ts

@@ -3293,6 +3293,10 @@ export class User {
 		};
 
 		for (const perpPosition of this.getActivePerpPositions()) {
+			const settledLpPosition = this.getPerpPositionWithLPSettle(
+				perpPosition.marketIndex,
+				perpPosition
+			)[0];
 			const perpMarket = this.driftClient.getPerpMarketAccount(
 				perpPosition.marketIndex
 			);
@@ -3301,7 +3305,7 @@ export class User {
 			).data;
 			const oraclePrice = oraclePriceData.price;
 			const worstCaseBaseAmount =
-				calculateWorstCaseBaseAssetAmount(perpPosition);
+				calculateWorstCaseBaseAssetAmount(settledLpPosition);
 
 			const marginRatio = new BN(
 				calculateMarketMarginRatio(