@drift-labs/sdk 2.38.1-beta.0 → 2.38.1-beta.10

package/src/driftClient.ts

@@ -113,7 +113,12 @@ import { isSpotPositionAvailable } from './math/spotPosition';
 import { calculateMarketMaxAvailableInsurance } from './math/market';
 import { fetchUserStatsAccount } from './accounts/fetch';
 import { castNumberToSpotPrecision } from './math/spotMarket';
-import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
+import {
+	JupiterClient,
+	QuoteResponse,
+	Route,
+	SwapMode,
+} from './jupiter/jupiterClient';
 import { getNonIdleUserFilter } from './memcmp';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { getMarinadeDepositIx, getMarinadeFinanceProgram } from './marinade';
@@ -174,6 +179,7 @@ export class DriftClient {
 		this.opts = config.opts || AnchorProvider.defaultOptions();
 		this.provider = new AnchorProvider(
 			config.connection,
+			// @ts-ignore
 			config.wallet,
 			this.opts
 		);
@@ -512,6 +518,7 @@ export class DriftClient {
 	): Promise<boolean> {
 		const newProvider = new AnchorProvider(
 			this.connection,
+			// @ts-ignore
 			newWallet,
 			this.opts
 		);
@@ -2473,6 +2480,7 @@ export class DriftClient {
 			);
 			this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
 
+			// @ts-ignore
 			return { txSig, signedFillTx: signedVersionedFillTx };
 		} else {
 			const marketOrderTx = wrapInTx(
@@ -3415,6 +3423,7 @@ export class DriftClient {
 		route,
 		reduceOnly,
 		txParams,
+		v6,
 	}: {
 		jupiterClient: JupiterClient;
 		outMarketIndex: number;
@@ -3427,19 +3436,44 @@ export class DriftClient {
 		route?: Route;
 		reduceOnly?: SwapReduceOnly;
 		txParams?: TxParams;
+		v6?: {
+			quote?: QuoteResponse;
+		};
 	}): Promise<TransactionSignature> {
-		const { ixs, lookupTables } = await this.getJupiterSwapIx({
-			jupiterClient,
-			outMarketIndex,
-			inMarketIndex,
-			outAssociatedTokenAccount,
-			inAssociatedTokenAccount,
-			amount,
-			slippageBps,
-			swapMode,
-			route,
-			reduceOnly,
-		});
+		let ixs: anchor.web3.TransactionInstruction[];
+		let lookupTables: anchor.web3.AddressLookupTableAccount[];
+
+		if (v6) {
+			const res = await this.getJupiterSwapIxV6({
+				jupiterClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				quote: v6.quote,
+				reduceOnly,
+			});
+			ixs = res.ixs;
+			lookupTables = res.lookupTables;
+		} else {
+			const res = await this.getJupiterSwapIx({
+				jupiterClient,
+				outMarketIndex,
+				inMarketIndex,
+				outAssociatedTokenAccount,
+				inAssociatedTokenAccount,
+				amount,
+				slippageBps,
+				swapMode,
+				route,
+				reduceOnly,
+			});
+			ixs = res.ixs;
+			lookupTables = res.lookupTables;
+		}
 
 		const tx = (await this.buildTransaction(
 			ixs,
@@ -3585,6 +3619,132 @@ export class DriftClient {
 		return { ixs, lookupTables };
 	}
 
+	public async getJupiterSwapIxV6({
+		jupiterClient,
+		outMarketIndex,
+		inMarketIndex,
+		outAssociatedTokenAccount,
+		inAssociatedTokenAccount,
+		amount,
+		slippageBps,
+		swapMode,
+		onlyDirectRoutes,
+		quote,
+		reduceOnly,
+		userAccountPublicKey,
+	}: {
+		jupiterClient: JupiterClient;
+		outMarketIndex: number;
+		inMarketIndex: number;
+		outAssociatedTokenAccount?: PublicKey;
+		inAssociatedTokenAccount?: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		onlyDirectRoutes?: boolean;
+		quote?: QuoteResponse;
+		reduceOnly?: SwapReduceOnly;
+		userAccountPublicKey?: PublicKey;
+	}): Promise<{
+		ixs: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		const outMarket = this.getSpotMarketAccount(outMarketIndex);
+		const inMarket = this.getSpotMarketAccount(inMarketIndex);
+
+		if (!quote) {
+			const fetchedQuote = await jupiterClient.getQuote({
+				inputMint: inMarket.mint,
+				outputMint: outMarket.mint,
+				amount,
+				slippageBps,
+				swapMode,
+				onlyDirectRoutes,
+			});
+
+			quote = fetchedQuote;
+		}
+
+		const transaction = await jupiterClient.getSwap({
+			quote,
+			userPublicKey: this.provider.wallet.publicKey,
+			slippageBps,
+		});
+
+		const { transactionMessage, lookupTables } =
+			await jupiterClient.getTransactionMessageAndLookupTables({
+				transaction,
+			});
+
+		const jupiterInstructions = jupiterClient.getJupiterInstructions({
+			transactionMessage,
+			inputMint: inMarket.mint,
+			outputMint: outMarket.mint,
+		});
+
+		const preInstructions = [];
+		if (!outAssociatedTokenAccount) {
+			outAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				outMarket.marketIndex,
+				false
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				outAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						outAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						outMarket.mint
+					)
+				);
+			}
+		}
+
+		if (!inAssociatedTokenAccount) {
+			inAssociatedTokenAccount = await this.getAssociatedTokenAccount(
+				inMarket.marketIndex,
+				false
+			);
+
+			const accountInfo = await this.connection.getAccountInfo(
+				inAssociatedTokenAccount
+			);
+			if (!accountInfo) {
+				preInstructions.push(
+					this.createAssociatedTokenAccountIdempotentInstruction(
+						inAssociatedTokenAccount,
+						this.provider.wallet.publicKey,
+						this.provider.wallet.publicKey,
+						inMarket.mint
+					)
+				);
+			}
+		}
+
+		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+			outMarketIndex,
+			inMarketIndex,
+			amountIn: amount,
+			inTokenAccount: inAssociatedTokenAccount,
+			outTokenAccount: outAssociatedTokenAccount,
+			reduceOnly,
+			userAccountPublicKey,
+		});
+
+		const ixs = [
+			...preInstructions,
+			beginSwapIx,
+			...jupiterInstructions,
+			endSwapIx,
+		];
+
+		return { ixs, lookupTables };
+	}
+
 	/**
 	 * Get the drift begin_swap and end_swap instructions
 	 *

package/src/examples/loadDlob.ts

@@ -28,6 +28,7 @@ const main = async () => {
 	// Set up the Provider
 	const provider = new AnchorProvider(
 		connection,
+		// @ts-ignore
 		wallet,
 		AnchorProvider.defaultOptions()
 	);

package/src/examples/makeTradeExample.ts

@@ -51,6 +51,7 @@ const main = async () => {
 	// Set up the Provider
 	const provider = new AnchorProvider(
 		connection,
+		// @ts-ignore
 		wallet,
 		AnchorProvider.defaultOptions()
 	);

package/src/idl/drift.json

@@ -3538,6 +3538,32 @@
         }
       ]
     },
+    {
+      "name": "updateSpotMarketScaleInitialAssetWeightStart",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "spotMarket",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "scaleInitialAssetWeightStart",
+          "type": "u64"
+        }
+      ]
+    },
     {
       "name": "updateSpotMarketOracle",
       "accounts": [
@@ -5357,12 +5383,21 @@
             ],
             "type": "u64"
           },
+          {
+            "name": "scaleInitialAssetWeightStart",
+            "docs": [
+              "When to begin scaling down the initial asset weight",
+              "disabled when 0",
+              "precision: QUOTE_PRECISION"
+            ],
+            "type": "u64"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                56
+                48
               ]
             }
           }

package/src/index.ts

@@ -5,6 +5,7 @@ import pyth from '@pythnetwork/client';
 export * from './tokenFaucet';
 export * from './oracles/types';
 export * from './oracles/pythClient';
+export * from './oracles/strictOraclePrice';
 export * from './types';
 export * from './constants/perpMarkets';
 export * from './accounts/fetch';
@@ -49,6 +50,7 @@ export * from './math/repeg';
 export * from './math/margin';
 export * from './math/insurance';
 export * from './math/superStake';
+export * from './math/spotPosition';
 export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
@@ -60,6 +62,7 @@ export * from './constants/numericConstants';
 export * from './serum/serumSubscriber';
 export * from './serum/serumFulfillmentConfigMap';
 export * from './phoenix/phoenixSubscriber';
+export * from './priorityFee/priorityFeeSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';

package/src/jupiter/jupiterClient.ts

@@ -41,8 +41,179 @@ export interface Route {
 	swapMode: SwapMode;
 }
 
+/**
+ *
+ * @export
+ * @interface RoutePlanStep
+ */
+export interface RoutePlanStep {
+	/**
+	 *
+	 * @type {SwapInfo}
+	 * @memberof RoutePlanStep
+	 */
+	swapInfo: SwapInfo;
+	/**
+	 *
+	 * @type {number}
+	 * @memberof RoutePlanStep
+	 */
+	percent: number;
+}
+
+export interface SwapInfo {
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	ammKey: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	label?: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	inputMint: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	outputMint: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	inAmount: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	outAmount: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	feeAmount: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof SwapInfo
+	 */
+	feeMint: string;
+}
+
+/**
+ *
+ * @export
+ * @interface PlatformFee
+ */
+export interface PlatformFee {
+	/**
+	 *
+	 * @type {string}
+	 * @memberof PlatformFee
+	 */
+	amount?: string;
+	/**
+	 *
+	 * @type {number}
+	 * @memberof PlatformFee
+	 */
+	feeBps?: number;
+}
+
+/**
+ *
+ * @export
+ * @interface QuoteResponse
+ */
+export interface QuoteResponse {
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	inputMint: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	inAmount: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	outputMint: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	outAmount: string;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	otherAmountThreshold: string;
+	/**
+	 *
+	 * @type {SwapMode}
+	 * @memberof QuoteResponse
+	 */
+	swapMode: SwapMode;
+	/**
+	 *
+	 * @type {number}
+	 * @memberof QuoteResponse
+	 */
+	slippageBps: number;
+	/**
+	 *
+	 * @type {PlatformFee}
+	 * @memberof QuoteResponse
+	 */
+	platformFee?: PlatformFee;
+	/**
+	 *
+	 * @type {string}
+	 * @memberof QuoteResponse
+	 */
+	priceImpactPct: string;
+	/**
+	 *
+	 * @type {Array<RoutePlanStep>}
+	 * @memberof QuoteResponse
+	 */
+	routePlan: Array<RoutePlanStep>;
+	/**
+	 *
+	 * @type {number}
+	 * @memberof QuoteResponse
+	 */
+	contextSlot?: number;
+	/**
+	 *
+	 * @type {number}
+	 * @memberof QuoteResponse
+	 */
+	timeTaken?: number;
+}
+
 export class JupiterClient {
-	url = 'https://quote-api.jup.ag/v4';
+	url = 'https://quote-api.jup.ag';
 	connection: Connection;
 	lookupTableCahce = new Map<string, AddressLookupTableAccount>();
 
@@ -51,6 +222,7 @@ export class JupiterClient {
 	}
 
 	/**
+	 * ** @deprecated - use getQuote
 	 * Get routes for a swap
 	 * @param inputMint the mint of the input token
 	 * @param outputMint the mint of the output token
@@ -84,13 +256,84 @@ export class JupiterClient {
 		}).toString();
 
 		const { data: routes } = await (
-			await fetch(`https://quote-api.jup.ag/v4/quote?${params}`)
+			await fetch(`${this.url}/v4/quote?${params}`)
 		).json();
 
 		return routes;
 	}
 
 	/**
+	 * Get routes for a swap
+	 * @param inputMint the mint of the input token
+	 * @param outputMint the mint of the output token
+	 * @param amount the amount of the input token
+	 * @param slippageBps the slippage tolerance in basis points
+	 * @param swapMode the swap mode (ExactIn or ExactOut)
+	 * @param onlyDirectRoutes whether to only return direct routes
+	 */
+	public async getQuote({
+		inputMint,
+		outputMint,
+		amount,
+		slippageBps = 50,
+		swapMode = 'ExactIn',
+		onlyDirectRoutes = false,
+	}: {
+		inputMint: PublicKey;
+		outputMint: PublicKey;
+		amount: BN;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		onlyDirectRoutes?: boolean;
+	}): Promise<QuoteResponse> {
+		const params = new URLSearchParams({
+			inputMint: inputMint.toString(),
+			outputMint: outputMint.toString(),
+			amount: amount.toString(),
+			slippageBps: slippageBps.toString(),
+			swapMode,
+			onlyDirectRoutes: onlyDirectRoutes.toString(),
+		}).toString();
+		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
+		return quote;
+	}
+
+	/**
+	 * Get a swap transaction for quote
+	 * @param quoteResponse quote to perform swap
+	 * @param userPublicKey the signer's wallet public key
+	 * @param slippageBps the slippage tolerance in basis points
+	 */
+	public async getSwap({
+		quote,
+		userPublicKey,
+		slippageBps = 50,
+	}: {
+		quote: QuoteResponse;
+		userPublicKey: PublicKey;
+		slippageBps?: number;
+	}): Promise<VersionedTransaction> {
+		const resp = await (
+			await fetch(`${this.url}/v6/swap`, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+				},
+				body: JSON.stringify({
+					quoteResponse: quote,
+					userPublicKey,
+					slippageBps,
+				}),
+			})
+		).json();
+		const { swapTransaction } = resp;
+
+		const swapTransactionBuf = Buffer.from(swapTransaction, 'base64');
+		return VersionedTransaction.deserialize(swapTransactionBuf);
+	}
+
+	/**
+	 * ** @deprecated - use getSwap
 	 * Get a swap transaction for a route
 	 * @param route the route to perform swap
 	 * @param userPublicKey the signer's wallet public key
@@ -106,7 +349,7 @@ export class JupiterClient {
 		slippageBps?: number;
 	}): Promise<VersionedTransaction> {
 		const resp = await (
-			await fetch(`${this.url}/swap`, {
+			await fetch(`${this.url}/v4/swap`, {
 				method: 'POST',
 				headers: {
 					'Content-Type': 'application/json',

package/src/math/spotBalance.ts

@@ -22,6 +22,7 @@ import {
 import { OraclePriceData } from '../oracles/types';
 import { PERCENTAGE_PRECISION } from '../constants/numericConstants';
 import { divCeil } from './utils';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
 
 /**
  * Calculates the balance of a given token amount including any accumulated interest. This
@@ -102,25 +103,23 @@ export function getSignedTokenAmount(
  *
  * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
  * @param {number} spotDecimals - The number of decimals in the token.
- * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
- * @param {BN} oraclePriceTwap - The Time-Weighted Average Price of the oracle.
+ * @param {StrictOraclePrice} strictOraclePrice - Contains oracle price and 5min twap.
  * @return {BN} The calculated value of the given token amount, scaled by `PRICE_PRECISION`
  */
 export function getStrictTokenValue(
 	tokenAmount: BN,
 	spotDecimals: number,
-	oraclePriceData: OraclePriceData,
-	oraclePriceTwap: BN
+	strictOraclePrice: StrictOraclePrice
 ): BN {
 	if (tokenAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
-	let price = oraclePriceData.price;
-	if (tokenAmount.gt(ZERO)) {
-		price = BN.min(oraclePriceData.price, oraclePriceTwap);
+	let price;
+	if (tokenAmount.gte(ZERO)) {
+		price = strictOraclePrice.min();
 	} else {
-		price = BN.max(oraclePriceData.price, oraclePriceTwap);
+		price = strictOraclePrice.max();
 	}
 
 	const precisionDecrease = TEN.pow(new BN(spotDecimals));
@@ -139,7 +138,7 @@ export function getStrictTokenValue(
 export function getTokenValue(
 	tokenAmount: BN,
 	spotDecimals: number,
-	oraclePriceData: OraclePriceData
+	oraclePriceData: Pick<OraclePriceData, 'price'>
 ): BN {
 	if (tokenAmount.eq(ZERO)) {
 		return ZERO;
@@ -152,6 +151,7 @@ export function getTokenValue(
 
 export function calculateAssetWeight(
 	balanceAmount: BN,
+	oraclePrice: BN,
 	spotMarket: SpotMarketAccount,
 	marginCategory: MarginCategory
 ): BN {
@@ -174,7 +174,7 @@ export function calculateAssetWeight(
 			assetWeight = calculateSizeDiscountAssetWeight(
 				sizeInAmmReservePrecision,
 				new BN(spotMarket.imfFactor),
-				new BN(spotMarket.initialAssetWeight)
+				calculateScaledInitialAssetWeight(spotMarket, oraclePrice)
 			);
 			break;
 		case 'Maintenance':
@@ -185,13 +185,39 @@ export function calculateAssetWeight(
 			);
 			break;
 		default:
-			assetWeight = new BN(spotMarket.initialAssetWeight);
+			assetWeight = calculateScaledInitialAssetWeight(spotMarket, oraclePrice);
 			break;
 	}
 
 	return assetWeight;
 }
 
+export function calculateScaledInitialAssetWeight(
+	spotMarket: SpotMarketAccount,
+	oraclePrice: BN
+): BN {
+	if (spotMarket.scaleInitialAssetWeightStart.eq(ZERO)) {
+		return new BN(spotMarket.initialAssetWeight);
+	}
+
+	const deposits = getTokenAmount(
+		spotMarket.depositBalance,
+		spotMarket,
+		SpotBalanceType.DEPOSIT
+	);
+	const depositsValue = getTokenValue(deposits, spotMarket.decimals, {
+		price: oraclePrice,
+	});
+
+	if (depositsValue.lt(spotMarket.scaleInitialAssetWeightStart)) {
+		return new BN(spotMarket.initialAssetWeight);
+	} else {
+		return new BN(spotMarket.initialAssetWeight)
+			.mul(spotMarket.scaleInitialAssetWeightStart)
+			.div(depositsValue);
+	}
+}
+
 export function calculateLiabilityWeight(
 	size: BN,
 	spotMarket: SpotMarketAccount,