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

package/src/driftClient.ts

@@ -1074,6 +1074,43 @@ export class DriftClient {
 		return ix;
 	}
 
+	public async updateUserReduceOnly(
+		updates: { reduceOnly: boolean; subAccountId: number }[]
+	): Promise<TransactionSignature> {
+		const ixs = await Promise.all(
+			updates.map(async ({ reduceOnly, subAccountId }) => {
+				return await this.getUpdateUserReduceOnlyIx(reduceOnly, subAccountId);
+			})
+		);
+
+		const tx = await this.buildTransaction(ixs, this.txParams);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
+
+	public async getUpdateUserReduceOnlyIx(
+		reduceOnly: boolean,
+		subAccountId: number
+	) {
+		const ix = await this.program.instruction.updateUserReduceOnly(
+			subAccountId,
+			reduceOnly,
+			{
+				accounts: {
+					user: getUserAccountPublicKeySync(
+						this.program.programId,
+						this.wallet.publicKey,
+						subAccountId
+					),
+					authority: this.wallet.publicKey,
+				},
+			}
+		);
+
+		return ix;
+	}
+
 	public async fetchAllUserAccounts(
 		includeIdle = true
 	): Promise<ProgramAccount<UserAccount>[]> {

package/src/events/parse.ts

@@ -1,13 +1,16 @@
 import { Program, Event } from '@coral-xyz/anchor';
 
 const driftProgramId = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
-const driftProgramStart = `Program ${driftProgramId} invoke`;
 const PROGRAM_LOG = 'Program log: ';
 const PROGRAM_DATA = 'Program data: ';
 const PROGRAM_LOG_START_INDEX = PROGRAM_LOG.length;
 const PROGRAM_DATA_START_INDEX = PROGRAM_DATA.length;
 
-export function parseLogs(program: Program, logs: string[]): Event[] {
+export function parseLogs(
+	program: Program,
+	logs: string[],
+	programId = driftProgramId
+): Event[] {
 	const events = [];
 	const execution = new ExecutionContext();
 	for (const log of logs) {
@@ -15,7 +18,12 @@ export function parseLogs(program: Program, logs: string[]): Event[] {
 			break;
 		}
 
-		const [event, newProgram, didPop] = handleLog(execution, log, program);
+		const [event, newProgram, didPop] = handleLog(
+			execution,
+			log,
+			program,
+			programId
+		);
 		if (event) {
 			events.push(event);
 		}
@@ -32,22 +40,24 @@ export function parseLogs(program: Program, logs: string[]): Event[] {
 function handleLog(
 	execution: ExecutionContext,
 	log: string,
-	program: Program
+	program: Program,
+	programId = driftProgramId
 ): [Event | null, string | null, boolean] {
 	// Executing program is drift program.
-	if (execution.stack.length > 0 && execution.program() === driftProgramId) {
-		return handleProgramLog(log, program);
+	if (execution.stack.length > 0 && execution.program() === programId) {
+		return handleProgramLog(log, program, programId);
 	}
 	// Executing program is not drift program.
 	else {
-		return [null, ...handleSystemLog(log)];
+		return [null, ...handleSystemLog(log, programId)];
 	}
 }
 
 // Handles logs from *drift* program.
 function handleProgramLog(
 	log: string,
-	program: Program
+	program: Program,
+	programId = driftProgramId
 ): [Event | null, string | null, boolean] {
 	// This is a `msg!` log or a `sol_log_data` log.
 	if (log.startsWith(PROGRAM_LOG)) {
@@ -59,21 +69,25 @@ function handleProgramLog(
 		const event = program.coder.events.decode(logStr);
 		return [event, null, false];
 	} else {
-		return [null, ...handleSystemLog(log)];
+		return [null, ...handleSystemLog(log, programId)];
 	}
 }
 
 // Handles logs when the current program being executing is *not* drift.
-function handleSystemLog(log: string): [string | null, boolean] {
+function handleSystemLog(
+	log: string,
+	programId = driftProgramId
+): [string | null, boolean] {
 	// System component.
 	const logStart = log.split(':')[0];
+	const programStart = `Program ${programId} invoke`;
 
 	// Did the program finish executing?
 	if (logStart.match(/^Program (.*) success/g) !== null) {
 		return [null, true];
 		// Recursive call.
-	} else if (logStart.startsWith(driftProgramStart)) {
-		return [driftProgramId, false];
+	} else if (logStart.startsWith(programStart)) {
+		return [programId, false];
 	}
 	// CPI call.
 	else if (logStart.includes('invoke')) {

package/src/idl/drift.json

@@ -2651,10 +2651,40 @@
           "name": "liquidatorFee",
           "type": "u32"
         },
+        {
+          "name": "ifLiquidationFee",
+          "type": "u32"
+        },
         {
           "name": "activeStatus",
           "type": "bool"
         },
+        {
+          "name": "assetTier",
+          "type": {
+            "defined": "AssetTier"
+          }
+        },
+        {
+          "name": "scaleInitialAssetWeightStart",
+          "type": "u64"
+        },
+        {
+          "name": "withdrawGuardThreshold",
+          "type": "u64"
+        },
+        {
+          "name": "orderTickSize",
+          "type": "u64"
+        },
+        {
+          "name": "orderStepSize",
+          "type": "u64"
+        },
+        {
+          "name": "ifTotalFactor",
+          "type": "u32"
+        },
         {
           "name": "name",
           "type": {
@@ -2943,10 +2973,62 @@
           "name": "liquidatorFee",
           "type": "u32"
         },
+        {
+          "name": "ifLiquidationFee",
+          "type": "u32"
+        },
+        {
+          "name": "imfFactor",
+          "type": "u32"
+        },
         {
           "name": "activeStatus",
           "type": "bool"
         },
+        {
+          "name": "baseSpread",
+          "type": "u32"
+        },
+        {
+          "name": "maxSpread",
+          "type": "u32"
+        },
+        {
+          "name": "maxOpenInterest",
+          "type": "u128"
+        },
+        {
+          "name": "maxRevenueWithdrawPerPeriod",
+          "type": "u64"
+        },
+        {
+          "name": "quoteMaxInsurance",
+          "type": "u64"
+        },
+        {
+          "name": "orderStepSize",
+          "type": "u64"
+        },
+        {
+          "name": "orderTickSize",
+          "type": "u64"
+        },
+        {
+          "name": "minOrderSize",
+          "type": "u64"
+        },
+        {
+          "name": "concentrationCoefScale",
+          "type": "u128"
+        },
+        {
+          "name": "curveUpdateIntensity",
+          "type": "u8"
+        },
+        {
+          "name": "ammJitIntensity",
+          "type": "u8"
+        },
         {
           "name": "name",
           "type": {
@@ -9119,6 +9201,9 @@
           {
             "name": "Speculative"
           },
+          {
+            "name": "HighlySpeculative"
+          },
           {
             "name": "Isolated"
           }

package/src/index.ts

@@ -99,5 +99,6 @@ export * from './auctionSubscriber';
 export * from './auctionSubscriber/types';
 export * from './memcmp';
 export * from './decode/user';
+export * from './blockhashSubscriber';
 
 export { BN, PublicKey, pyth };

package/src/math/funding.ts

@@ -252,10 +252,6 @@ function getMaxPriceDivergenceForFundingRate(
 		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);
 	}

package/src/math/oracles.ts

@@ -39,7 +39,7 @@ export function getMaxConfidenceIntervalMultiplier(
 		maxConfidenceIntervalMultiplier = new BN(2);
 	} else if (isVariant(market.contractTier, 'speculative')) {
 		maxConfidenceIntervalMultiplier = new BN(10);
-	} else if (isVariant(market.contractTier, 'isolated')) {
+	} else {
 		maxConfidenceIntervalMultiplier = new BN(50);
 	}
 	return maxConfidenceIntervalMultiplier;

package/src/math/tiers.ts

@@ -9,7 +9,7 @@ export function getPerpMarketTierNumber(perpMarket: PerpMarketAccount): number {
 		return 2;
 	} else if (isVariant(perpMarket.contractTier, 'speculative')) {
 		return 3;
-	} else if (isVariant(perpMarket.contractTier, 'isolated')) {
+	} else if (isVariant(perpMarket.contractTier, 'highlySpeculative')) {
 		return 4;
 	} else {
 		return 5;

package/src/oracles/prelaunchOracleClient.ts

@@ -31,6 +31,7 @@ export class PrelaunchOracleClient implements OracleClient {
 			slot: prelaunchOracle.ammLastUpdateSlot,
 			confidence: prelaunchOracle.confidence,
 			hasSufficientNumberOfDataPoints: true,
+			maxPrice: prelaunchOracle.maxPrice,
 		};
 	}
 }

package/src/oracles/types.ts

@@ -9,6 +9,7 @@ export type OraclePriceData = {
 	hasSufficientNumberOfDataPoints: boolean;
 	twap?: BN;
 	twapConfidence?: BN;
+	maxPrice?: BN; // pre-launch markets only
 };
 
 export type OracleInfo = {

package/src/tx/baseTxSender.ts

@@ -112,7 +112,8 @@ export abstract class BaseTxSender implements TxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
@@ -121,11 +122,18 @@ export abstract class BaseTxSender implements TxSender {
 			opts = this.opts;
 		}
 
+		let recentBlockhash = '';
+		if (blockhash) {
+			recentBlockhash = blockhash;
+		} else {
+			recentBlockhash = (
+				await this.connection.getLatestBlockhash(opts.preflightCommitment)
+			).blockhash;
+		}
+
 		const message = new TransactionMessage({
 			payerKey: this.wallet.publicKey,
-			recentBlockhash: (
-				await this.connection.getLatestBlockhash(opts.preflightCommitment)
-			).blockhash,
+			recentBlockhash,
 			instructions: ixs,
 		}).compileToV0Message(lookupTableAccounts);
 

package/src/tx/fastSingleTxSender.ts

@@ -109,7 +109,8 @@ export class FastSingleTxSender extends BaseTxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
@@ -118,12 +119,19 @@ export class FastSingleTxSender extends BaseTxSender {
 			opts = this.opts;
 		}
 
-		const message = new TransactionMessage({
-			payerKey: this.wallet.publicKey,
-			recentBlockhash:
+		let recentBlockhash = '';
+		if (blockhash) {
+			recentBlockhash = blockhash;
+		} else {
+			recentBlockhash =
 				this.recentBlockhash ??
 				(await this.connection.getLatestBlockhash(opts.preflightCommitment))
-					.blockhash,
+					.blockhash;
+		}
+
+		const message = new TransactionMessage({
+			payerKey: this.wallet.publicKey,
+			recentBlockhash,
 			instructions: ixs,
 		}).compileToV0Message(lookupTableAccounts);
 

package/src/tx/types.ts

@@ -47,7 +47,8 @@ export interface TxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction>;
 
 	sendRawTransaction(

package/src/types.ts

@@ -58,6 +58,7 @@ export class ContractTier {
 	static readonly B = { b: {} };
 	static readonly C = { c: {} };
 	static readonly SPECULATIVE = { speculative: {} };
+	static readonly HIGHLY_SPECULATIVE = { highlySpeculative: {} };
 	static readonly ISOLATED = { isolated: {} };
 }
 

package/src/user.ts

@@ -1975,21 +1975,25 @@ export class User {
 	/**
 	 * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
 	 * @param marketIndex
-	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
+	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^9
+	 * @param estimatedEntryPrice
 	 * @param marginCategory // allow Initial to be passed in if we are trying to calculate price for DLP de-risking
+	 * @param includeOpenOrders
 	 * @returns Precision : PRICE_PRECISION
 	 */
 	public liquidationPrice(
 		marketIndex: number,
 		positionBaseSizeChange: BN = ZERO,
 		estimatedEntryPrice: BN = ZERO,
-		marginCategory: MarginCategory = 'Maintenance'
+		marginCategory: MarginCategory = 'Maintenance',
+		includeOpenOrders = false
 	): BN {
 		const totalCollateral = this.getTotalCollateral(marginCategory);
 		const marginRequirement = this.getMarginRequirement(
 			marginCategory,
 			undefined,
-			false
+			false,
+			includeOpenOrders
 		);
 		let freeCollateral = BN.max(ZERO, totalCollateral.sub(marginRequirement));
 
@@ -2015,7 +2019,8 @@ export class User {
 				oraclePrice,
 				currentPerpPosition,
 				positionBaseSizeChange,
-				estimatedEntryPrice
+				estimatedEntryPrice,
+				includeOpenOrders
 			);
 
 		freeCollateral = freeCollateral.add(freeCollateralChangeFromNewPosition);
@@ -2024,7 +2029,8 @@ export class User {
 			market,
 			currentPerpPosition,
 			positionBaseSizeChange,
-			marginCategory
+			marginCategory,
+			includeOpenOrders
 		);
 
 		if (!freeCollateralDelta) {
@@ -2082,7 +2088,8 @@ export class User {
 		oraclePrice: BN,
 		perpPosition: PerpPosition,
 		positionBaseSizeChange: BN,
-		estimatedEntryPrice: BN
+		estimatedEntryPrice: BN,
+		includeOpenOrders: boolean
 	): BN {
 		let freeCollateralChange = ZERO;
 
@@ -2097,8 +2104,6 @@ export class User {
 			if (positionBaseSizeChange.gt(ZERO)) {
 				freeCollateralChange = costBasis.sub(newPositionValue);
 			} else {
-				console.log('newPositionValue', newPositionValue.toString());
-				console.log('costBasis', costBasis.toString());
 				freeCollateralChange = newPositionValue.sub(costBasis);
 			}
 
@@ -2111,24 +2116,23 @@ export class User {
 			freeCollateralChange = freeCollateralChange.sub(takerFee);
 		}
 
-		const worstCaseBaseAssetAmount =
-			calculateWorstCaseBaseAssetAmount(perpPosition);
+		const baseAssetAmount = includeOpenOrders
+			? calculateWorstCaseBaseAssetAmount(perpPosition)
+			: perpPosition.baseAssetAmount;
 
-		const newWorstCaseBaseAssetAmount = worstCaseBaseAssetAmount.add(
-			positionBaseSizeChange
-		);
+		const newBaseAssetAmount = baseAssetAmount.add(positionBaseSizeChange);
 
 		const newMarginRatio = calculateMarketMarginRatio(
 			market,
-			newWorstCaseBaseAssetAmount.abs(),
+			newBaseAssetAmount.abs(),
 			'Maintenance'
 		);
 
 		// update free collateral to account for new margin requirement from position change
 		freeCollateralChange = freeCollateralChange.sub(
-			newWorstCaseBaseAssetAmount
+			newBaseAssetAmount
 				.abs()
-				.sub(worstCaseBaseAssetAmount.abs())
+				.sub(baseAssetAmount.abs())
 				.mul(oraclePrice)
 				.div(BASE_PRECISION)
 				.mul(new BN(newMarginRatio))
@@ -2142,25 +2146,23 @@ export class User {
 		market: PerpMarketAccount,
 		perpPosition: PerpPosition,
 		positionBaseSizeChange: BN,
-		marginCategory: MarginCategory = 'Maintenance'
+		marginCategory: MarginCategory = 'Maintenance',
+		includeOpenOrders = false
 	): BN | undefined {
-		const currentBaseAssetAmount = perpPosition.baseAssetAmount;
+		const baseAssetAmount = includeOpenOrders
+			? calculateWorstCaseBaseAssetAmount(perpPosition)
+			: perpPosition.baseAssetAmount;
 
-		const worstCaseBaseAssetAmount =
-			calculateWorstCaseBaseAssetAmount(perpPosition);
-		const orderBaseAssetAmount = worstCaseBaseAssetAmount.sub(
-			currentBaseAssetAmount
-		);
-		const proposedBaseAssetAmount = currentBaseAssetAmount.add(
-			positionBaseSizeChange
-		);
-		const proposedWorstCaseBaseAssetAmount = worstCaseBaseAssetAmount.add(
-			positionBaseSizeChange
+		// zero if include orders == false
+		const orderBaseAssetAmount = baseAssetAmount.sub(
+			perpPosition.baseAssetAmount
 		);
 
+		const proposedBaseAssetAmount = baseAssetAmount.add(positionBaseSizeChange);
+
 		const marginRatio = calculateMarketMarginRatio(
 			market,
-			proposedWorstCaseBaseAssetAmount.abs(),
+			proposedBaseAssetAmount.abs(),
 			marginCategory,
 			this.getUserAccount().maxMarginRatio
 		);
@@ -2168,7 +2170,7 @@ export class User {
 			.mul(QUOTE_PRECISION)
 			.div(MARGIN_PRECISION);
 
-		if (proposedWorstCaseBaseAssetAmount.eq(ZERO)) {
+		if (proposedBaseAssetAmount.eq(ZERO)) {
 			return undefined;
 		}
 

package/tests/amm/test.ts

@@ -1193,7 +1193,9 @@ describe('AMM Tests', () => {
 		};
 
 		// good oracle
-		assert(isOracleValid(mockMarket1, oraclePriceData, oracleGuardRails, slot + 5));
+		assert(
+			isOracleValid(mockMarket1, oraclePriceData, oracleGuardRails, slot + 5)
+		);
 
 		// conf too high
 		assert(

package/tests/dlob/test.ts

@@ -6614,6 +6614,63 @@ describe('Uncross L2', () => {
 		);
 	});
 
+	it('Handles user crossing bid in second level', () => {
+		const oraclePrice = new BN(190.3843 * PRICE_PRECISION.toNumber());
+		const bids = [
+			[190.59, 2],
+			[190.588, 58.3],
+			[190.5557, 5],
+			[190.5547, 5],
+			[190.5508, 5],
+			[190.541, 2],
+			[190.5099, 49.1],
+			[190.5, 60],
+		].map(([price, size]) => ({
+			price: new BN(price * PRICE_PRECISION.toNumber()),
+			size: new BN(size * BASE_PRECISION.toNumber()),
+			sources: { vamm: new BN(size * BASE_PRECISION.toNumber()) },
+		}));
+
+		const asks = [
+			[190.5, 86.5],
+			[190.6159, 1],
+			[190.656, 10.5],
+			[190.6561, 1],
+			[190.6585, 5],
+			[190.6595, 5],
+			[190.6596, 5],
+		].map(([price, size]) => ({
+			price: new BN(price * PRICE_PRECISION.toNumber()),
+			size: new BN(size * BASE_PRECISION.toNumber()),
+			sources: { vamm: new BN(size * BASE_PRECISION.toNumber()) },
+		}));
+
+		expect(asksAreSortedAsc(asks), 'Input asks are ascending').to.be.true;
+		expect(bidsAreSortedDesc(bids), 'Input bids are descending').to.be.true;
+
+		const groupingSize = new BN('100');
+
+		const userBidPrice = new BN(190.588 * PRICE_PRECISION.toNumber());
+		const userBids = new Set<string>([userBidPrice.toString()]);
+
+		const { bids: newBids, asks: newAsks } = uncrossL2(
+			bids,
+			asks,
+			oraclePrice,
+			oraclePrice,
+			oraclePrice,
+			groupingSize,
+			userBids,
+			new Set<string>()
+		);
+
+		expect(asksAreSortedAsc(newAsks), 'Uncrossed asks are ascending').to.be
+			.true;
+		expect(bidsAreSortedDesc(newBids), 'Uncrossed bids are descending').to.be
+			.true;
+		expect(newBids[0].price.toString()).to.equal(userBidPrice.toString());
+	});
+
 	it('Handles edge case bide and asks with large cross and an overlapping level', () => {
 		const bids = [
 			'104411000',