@drift-labs/sdk 2.31.1-beta.13 → 2.31.1-beta.14

package/VERSION

@@ -1 +1 @@
-2.31.1-beta.13
+2.31.1-beta.14

package/lib/driftClient.d.ts

@@ -116,6 +116,7 @@ export declare class DriftClient {
     initializeReferrerName(name: string): Promise<TransactionSignature>;
     updateUserName(name: string, subAccountId?: number): Promise<TransactionSignature>;
     updateUserCustomMarginRatio(marginRatio: number, subAccountId?: number): Promise<TransactionSignature>;
+    getUpdateUserMarginTradingEnabledIx(marginTradingEnabled: boolean, subAccountId?: number, userAccountPublicKey?: PublicKey): Promise<TransactionInstruction>;
     updateUserMarginTradingEnabled(marginTradingEnabled: boolean, subAccountId?: number): Promise<TransactionSignature>;
     updateUserDelegate(delegate: PublicKey, subAccountId?: number): Promise<TransactionSignature>;
     fetchAllUserAccounts(includeIdle?: boolean): Promise<ProgramAccount<UserAccount>[]>;
@@ -323,6 +324,22 @@ export declare class DriftClient {
         reduceOnly?: SwapReduceOnly;
         txParams?: TxParams;
     }): Promise<TransactionSignature>;
+    getJupiterSwapIx({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, userAccountPublicKey, }: {
+        jupiterClient: JupiterClient;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        outAssociatedTokenAccount?: PublicKey;
+        inAssociatedTokenAccount?: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        route?: Route;
+        reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
     /**
      * Get the drift begin_swap and end_swap instructions
      *
@@ -332,8 +349,10 @@ export declare class DriftClient {
      * @param inTokenAccount the token account to move the tokens being sold
      * @param outTokenAccount the token account to receive the tokens being bought
      * @param limitPrice the limit price of the swap
+     * @param reduceOnly
+     * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
      */
-    getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, }: {
+    getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }: {
         outMarketIndex: number;
         inMarketIndex: number;
         amountIn: BN;
@@ -341,6 +360,7 @@ export declare class DriftClient {
         outTokenAccount: PublicKey;
         limitPrice?: BN;
         reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
     }): Promise<{
         beginSwapIx: TransactionInstruction;
         endSwapIx: TransactionInstruction;
@@ -348,8 +368,9 @@ export declare class DriftClient {
     stakeForMSOL({ amount }: {
         amount: BN;
     }): Promise<TxSigAndSlot>;
-    getStakeForMSOLIx({ amount, }: {
+    getStakeForMSOLIx({ amount, userAccountPublicKey, }: {
         amount: BN;
+        userAccountPublicKey?: PublicKey;
     }): Promise<TransactionInstruction[]>;
     triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order, txParams?: TxParams): Promise<TransactionSignature>;
     getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;

package/lib/driftClient.js

@@ -508,6 +508,27 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
+    async getUpdateUserMarginTradingEnabledIx(marginTradingEnabled, subAccountId = 0, userAccountPublicKey) {
+        const userAccountPublicKeyToUse = userAccountPublicKey ||
+            (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId);
+        await this.addUser(subAccountId, this.wallet.publicKey);
+        let remainingAccounts;
+        try {
+            remainingAccounts = this.getRemainingAccounts({
+                userAccounts: [this.getUserAccount(subAccountId)],
+            });
+        }
+        catch (err) {
+            remainingAccounts = [];
+        }
+        return await this.program.instruction.updateUserMarginTradingEnabled(subAccountId, marginTradingEnabled, {
+            accounts: {
+                user: userAccountPublicKeyToUse,
+                authority: this.wallet.publicKey,
+            },
+            remainingAccounts,
+        });
+    }
     async updateUserMarginTradingEnabled(marginTradingEnabled, subAccountId = 0) {
         const userAccountPublicKey = (0, pda_1.getUserAccountPublicKeySync)(this.program.programId, this.wallet.publicKey, subAccountId);
         await this.addUser(subAccountId, this.wallet.publicKey);
@@ -1925,6 +1946,25 @@ class DriftClient {
      * @param txParams
      */
     async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }) {
+        const { ixs, lookupTables } = await this.getJupiterSwapIx({
+            jupiterClient,
+            outMarketIndex,
+            inMarketIndex,
+            outAssociatedTokenAccount,
+            inAssociatedTokenAccount,
+            amount,
+            slippageBps,
+            swapMode,
+            route,
+            reduceOnly,
+        });
+        const tx = (await this.buildTransaction(ixs, txParams, 0, lookupTables));
+        const { txSig, slot } = await this.sendTransaction(tx);
+        this.spotMarketLastSlotCache.set(outMarketIndex, slot);
+        this.spotMarketLastSlotCache.set(inMarketIndex, slot);
+        return txSig;
+    }
+    async getJupiterSwapIx({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, userAccountPublicKey, }) {
         const outMarket = this.getSpotMarketAccount(outMarketIndex);
         const inMarket = this.getSpotMarketAccount(inMarketIndex);
         if (!route) {
@@ -1975,18 +2015,15 @@ class DriftClient {
             inTokenAccount: inAssociatedTokenAccount,
             outTokenAccount: outAssociatedTokenAccount,
             reduceOnly,
+            userAccountPublicKey,
         });
-        const instructions = [
+        const ixs = [
             ...preInstructions,
             beginSwapIx,
             ...jupiterInstructions,
             endSwapIx,
         ];
-        const tx = (await this.buildTransaction(instructions, txParams, 0, lookupTables));
-        const { txSig, slot } = await this.sendTransaction(tx);
-        this.spotMarketLastSlotCache.set(outMarketIndex, slot);
-        this.spotMarketLastSlotCache.set(inMarketIndex, slot);
-        return txSig;
+        return { ixs, lookupTables };
     }
     /**
      * Get the drift begin_swap and end_swap instructions
@@ -1997,11 +2034,14 @@ class DriftClient {
      * @param inTokenAccount the token account to move the tokens being sold
      * @param outTokenAccount the token account to receive the tokens being bought
      * @param limitPrice the limit price of the swap
+     * @param reduceOnly
+     * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
      */
-    async getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, }) {
-        const userAccountPublicKey = await this.getUserAccountPublicKey();
+    async getSwapIx({ outMarketIndex, inMarketIndex, amountIn, inTokenAccount, outTokenAccount, limitPrice, reduceOnly, userAccountPublicKey, }) {
+        const userAccountPublicKeyToUse = userAccountPublicKey || (await this.getUserAccountPublicKey());
+        const userAccounts = this.hasUser() ? [this.getUserAccount()] : [];
         const remainingAccounts = this.getRemainingAccounts({
-            userAccounts: [this.getUserAccount()],
+            userAccounts,
             writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
         });
         const outSpotMarket = this.getSpotMarketAccount(outMarketIndex);
@@ -2009,7 +2049,7 @@ class DriftClient {
         const beginSwapIx = await this.program.instruction.beginSwap(inMarketIndex, outMarketIndex, amountIn, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user: userAccountPublicKeyToUse,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.authority,
                 outSpotMarketVault: outSpotMarket.vault,
@@ -2025,7 +2065,7 @@ class DriftClient {
         const endSwapIx = await this.program.instruction.endSwap(inMarketIndex, outMarketIndex, limitPrice !== null && limitPrice !== void 0 ? limitPrice : null, reduceOnly !== null && reduceOnly !== void 0 ? reduceOnly : null, {
             accounts: {
                 state: await this.getStatePublicKey(),
-                user: userAccountPublicKey,
+                user: userAccountPublicKeyToUse,
                 userStats: this.getUserStatsAccountPublicKey(),
                 authority: this.authority,
                 outSpotMarketVault: outSpotMarket.vault,
@@ -2045,7 +2085,7 @@ class DriftClient {
         const tx = await this.buildTransaction(ixs);
         return this.sendTransaction(tx);
     }
-    async getStakeForMSOLIx({ amount, }) {
+    async getStakeForMSOLIx({ amount, userAccountPublicKey, }) {
         const wSOLMint = this.getSpotMarketAccount(1).mint;
         const mSOLAccount = await this.getAssociatedTokenAccount(2);
         const wSOLAccount = await this.getAssociatedTokenAccount(1, false);
@@ -2058,6 +2098,7 @@ class DriftClient {
             amountIn: amount,
             inTokenAccount: wSOLAccount,
             outTokenAccount: mSOLAccount,
+            userAccountPublicKey,
         });
         const program = (0, marinade_1.getMarinadeFinanceProgram)(this.provider);
         const depositIx = await (0, marinade_1.getMarinadeDepositIx)({

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.31.1-beta.12",
+    "version": "2.31.1-beta.13",
     "name": "drift",
     "instructions": [
         {

package/lib/math/superStake.d.ts

@@ -0,0 +1,15 @@
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { JupiterClient } from '../jupiter/jupiterClient';
+import { DriftClient } from '../driftClient';
+import { BN } from '@coral-xyz/anchor';
+export declare function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, }: {
+    amount: BN;
+    jupiterClient: JupiterClient;
+    driftClient: DriftClient;
+    userAccountPublicKey?: PublicKey;
+}): Promise<{
+    ixs: TransactionInstruction[];
+    lookupTables: AddressLookupTableAccount[];
+    method: 'jupiter' | 'marinade';
+    price: number;
+}>;

package/lib/math/superStake.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBestSuperStakeIxs = void 0;
+const marinade_1 = require("../marinade");
+async function findBestSuperStakeIxs({ amount, jupiterClient, driftClient, userAccountPublicKey, }) {
+    const marinadeProgram = (0, marinade_1.getMarinadeFinanceProgram)(driftClient.provider);
+    const marinadePrice = await (0, marinade_1.getMarinadeMSolPrice)(marinadeProgram);
+    const solMint = driftClient.getSpotMarketAccount(1).mint;
+    const mSOLMint = driftClient.getSpotMarketAccount(2).mint;
+    const jupiterRoutes = await jupiterClient.getRoutes({
+        inputMint: solMint,
+        outputMint: mSOLMint,
+        amount,
+    });
+    const bestRoute = jupiterRoutes[0];
+    const jupiterPrice = bestRoute.inAmount / bestRoute.outAmount;
+    if (marinadePrice <= jupiterPrice) {
+        const ixs = await driftClient.getStakeForMSOLIx({ amount });
+        return {
+            method: 'marinade',
+            ixs,
+            lookupTables: [],
+            price: marinadePrice,
+        };
+    }
+    else {
+        const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
+            inMarketIndex: 1,
+            outMarketIndex: 2,
+            route: bestRoute,
+            jupiterClient,
+            amount,
+            userAccountPublicKey,
+        });
+        return {
+            method: 'jupiter',
+            ixs,
+            lookupTables,
+            price: jupiterPrice,
+        };
+    }
+}
+exports.findBestSuperStakeIxs = findBestSuperStakeIxs;

package/package.json

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

package/src/driftClient.ts

@@ -863,6 +863,43 @@ export class DriftClient {
 		return txSig;
 	}
 
+	public async getUpdateUserMarginTradingEnabledIx(
+		marginTradingEnabled: boolean,
+		subAccountId = 0,
+		userAccountPublicKey?: PublicKey
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKeyToUse =
+			userAccountPublicKey ||
+			getUserAccountPublicKeySync(
+				this.program.programId,
+				this.wallet.publicKey,
+				subAccountId
+			);
+
+		await this.addUser(subAccountId, this.wallet.publicKey);
+
+		let remainingAccounts;
+		try {
+			remainingAccounts = this.getRemainingAccounts({
+				userAccounts: [this.getUserAccount(subAccountId)],
+			});
+		} catch (err) {
+			remainingAccounts = [];
+		}
+
+		return await this.program.instruction.updateUserMarginTradingEnabled(
+			subAccountId,
+			marginTradingEnabled,
+			{
+				accounts: {
+					user: userAccountPublicKeyToUse,
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async updateUserMarginTradingEnabled(
 		marginTradingEnabled: boolean,
 		subAccountId = 0
@@ -3351,6 +3388,61 @@ export class DriftClient {
 		reduceOnly?: SwapReduceOnly;
 		txParams?: TxParams;
 	}): Promise<TransactionSignature> {
+		const { ixs, lookupTables } = await this.getJupiterSwapIx({
+			jupiterClient,
+			outMarketIndex,
+			inMarketIndex,
+			outAssociatedTokenAccount,
+			inAssociatedTokenAccount,
+			amount,
+			slippageBps,
+			swapMode,
+			route,
+			reduceOnly,
+		});
+
+		const tx = (await this.buildTransaction(
+			ixs,
+			txParams,
+			0,
+			lookupTables
+		)) as VersionedTransaction;
+
+		const { txSig, slot } = await this.sendTransaction(tx);
+		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
+		this.spotMarketLastSlotCache.set(inMarketIndex, slot);
+
+		return txSig;
+	}
+
+	public async getJupiterSwapIx({
+		jupiterClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		swapMode,
+		route,
+		reduceOnly,
+		userAccountPublicKey,
+	}: {
+		jupiterClient: JupiterClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount?: PublicKey;
+		inAssociatedTokenAccount?: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		route?: Route;
+		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
+	}): Promise<{
+		ixs: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
 		const outMarket = this.getSpotMarketAccount(outMarketIndex);
 		const inMarket = this.getSpotMarketAccount(inMarketIndex);
 
@@ -3437,27 +3529,17 @@ export class DriftClient {
 			inTokenAccount: inAssociatedTokenAccount,
 			outTokenAccount: outAssociatedTokenAccount,
 			reduceOnly,
+			userAccountPublicKey,
 		});
 
-		const instructions = [
+		const ixs = [
 			...preInstructions,
 			beginSwapIx,
 			...jupiterInstructions,
 			endSwapIx,
 		];
 
-		const tx = (await this.buildTransaction(
-			instructions,
-			txParams,
-			0,
-			lookupTables
-		)) as VersionedTransaction;
-
-		const { txSig, slot } = await this.sendTransaction(tx);
-		this.spotMarketLastSlotCache.set(outMarketIndex, slot);
-		this.spotMarketLastSlotCache.set(inMarketIndex, slot);
-
-		return txSig;
+		return { ixs, lookupTables };
 	}
 
 	/**
@@ -3469,6 +3551,8 @@ export class DriftClient {
 	 * @param inTokenAccount the token account to move the tokens being sold
 	 * @param outTokenAccount the token account to receive the tokens being bought
 	 * @param limitPrice the limit price of the swap
+	 * @param reduceOnly
+	 * @param userAccountPublicKey optional, specify a custom userAccountPublicKey to use instead of getting the current user account; can be helpful if the account is being created within the current tx
 	 */
 	public async getSwapIx({
 		outMarketIndex,
@@ -3478,6 +3562,7 @@ export class DriftClient {
 		outTokenAccount,
 		limitPrice,
 		reduceOnly,
+		userAccountPublicKey,
 	}: {
 		outMarketIndex: number;
 		inMarketIndex: number;
@@ -3486,14 +3571,17 @@ export class DriftClient {
 		outTokenAccount: PublicKey;
 		limitPrice?: BN;
 		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
 	}): Promise<{
 		beginSwapIx: TransactionInstruction;
 		endSwapIx: TransactionInstruction;
 	}> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccountPublicKeyToUse =
+			userAccountPublicKey || (await this.getUserAccountPublicKey());
 
+		const userAccounts = this.hasUser() ? [this.getUserAccount()] : [];
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
+			userAccounts,
 			writableSpotMarketIndexes: [outMarketIndex, inMarketIndex],
 		});
 
@@ -3507,7 +3595,7 @@ export class DriftClient {
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
+					user: userAccountPublicKeyToUse,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.authority,
 					outSpotMarketVault: outSpotMarket.vault,
@@ -3530,7 +3618,7 @@ export class DriftClient {
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),
-					user: userAccountPublicKey,
+					user: userAccountPublicKeyToUse,
 					userStats: this.getUserStatsAccountPublicKey(),
 					authority: this.authority,
 					outSpotMarketVault: outSpotMarket.vault,
@@ -3556,8 +3644,10 @@ export class DriftClient {
 
 	public async getStakeForMSOLIx({
 		amount,
+		userAccountPublicKey,
 	}: {
 		amount: BN;
+		userAccountPublicKey?: PublicKey;
 	}): Promise<TransactionInstruction[]> {
 		const wSOLMint = this.getSpotMarketAccount(1).mint;
 		const mSOLAccount = await this.getAssociatedTokenAccount(2);
@@ -3585,6 +3675,7 @@ export class DriftClient {
 			amountIn: amount,
 			inTokenAccount: wSOLAccount,
 			outTokenAccount: mSOLAccount,
+			userAccountPublicKey,
 		});
 
 		const program = getMarinadeFinanceProgram(this.provider);

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.31.1-beta.13",
+  "version": "2.31.1-beta.14",
   "name": "drift",
   "instructions": [
     {

package/src/math/superStake.ts

@@ -0,0 +1,65 @@
+import {
+	AddressLookupTableAccount,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import { JupiterClient } from '../jupiter/jupiterClient';
+import { DriftClient } from '../driftClient';
+import { getMarinadeFinanceProgram, getMarinadeMSolPrice } from '../marinade';
+import { BN } from '@coral-xyz/anchor';
+
+export async function findBestSuperStakeIxs({
+	amount,
+	jupiterClient,
+	driftClient,
+	userAccountPublicKey,
+}: {
+	amount: BN;
+	jupiterClient: JupiterClient;
+	driftClient: DriftClient;
+	userAccountPublicKey?: PublicKey;
+}): Promise<{
+	ixs: TransactionInstruction[];
+	lookupTables: AddressLookupTableAccount[];
+	method: 'jupiter' | 'marinade';
+	price: number;
+}> {
+	const marinadeProgram = getMarinadeFinanceProgram(driftClient.provider);
+	const marinadePrice = await getMarinadeMSolPrice(marinadeProgram);
+
+	const solMint = driftClient.getSpotMarketAccount(1).mint;
+	const mSOLMint = driftClient.getSpotMarketAccount(2).mint;
+	const jupiterRoutes = await jupiterClient.getRoutes({
+		inputMint: solMint,
+		outputMint: mSOLMint,
+		amount,
+	});
+
+	const bestRoute = jupiterRoutes[0];
+	const jupiterPrice = bestRoute.inAmount / bestRoute.outAmount;
+
+	if (marinadePrice <= jupiterPrice) {
+		const ixs = await driftClient.getStakeForMSOLIx({ amount });
+		return {
+			method: 'marinade',
+			ixs,
+			lookupTables: [],
+			price: marinadePrice,
+		};
+	} else {
+		const { ixs, lookupTables } = await driftClient.getJupiterSwapIx({
+			inMarketIndex: 1,
+			outMarketIndex: 2,
+			route: bestRoute,
+			jupiterClient,
+			amount,
+			userAccountPublicKey,
+		});
+		return {
+			method: 'jupiter',
+			ixs,
+			lookupTables,
+			price: jupiterPrice,
+		};
+	}
+}