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

package/src/adminClient.ts

@@ -1,6 +1,7 @@
 import {
 	PublicKey,
 	SYSVAR_RENT_PUBKEY,
+	TransactionInstruction,
 	TransactionSignature,
 } from '@solana/web3.js';
 import {
@@ -31,7 +32,13 @@ import {
 import { squareRootBN } from './math/utils';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { DriftClient } from './driftClient';
-import { PEG_PRECISION } from './constants/numericConstants';
+import {
+	PEG_PRECISION,
+	ZERO,
+	ONE,
+	BASE_PRECISION,
+	PRICE_PRECISION,
+} from './constants/numericConstants';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
 import { PROGRAM_ID as PHOENIX_PROGRAM_ID } from '@ellipsis-labs/phoenix-sdk';
@@ -84,10 +91,84 @@ export class AdminClient extends DriftClient {
 		maintenanceLiabilityWeight: number,
 		imfFactor = 0,
 		liquidatorFee = 0,
+		ifLiquidationFee = 0,
 		activeStatus = true,
+		assetTier = AssetTier.COLLATERAL,
+		scaleInitialAssetWeightStart = ZERO,
+		withdrawGuardThreshold = ZERO,
+		orderTickSize = ONE,
+		orderStepSize = ONE,
+		ifTotalFactor = 0,
 		name = DEFAULT_MARKET_NAME
 	): Promise<TransactionSignature> {
 		const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
+
+		const initializeIx = await this.getInitializeSpotMarketIx(
+			this.wallet.publicKey,
+			mint,
+			optimalUtilization,
+			optimalRate,
+			maxRate,
+			oracle,
+			oracleSource,
+			initialAssetWeight,
+			maintenanceAssetWeight,
+			initialLiabilityWeight,
+			maintenanceLiabilityWeight,
+			imfFactor,
+			liquidatorFee,
+			ifLiquidationFee,
+			activeStatus,
+			assetTier,
+			scaleInitialAssetWeightStart,
+			withdrawGuardThreshold,
+			orderTickSize,
+			orderStepSize,
+			ifTotalFactor,
+			name
+		);
+
+		const tx = await this.buildTransaction(initializeIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		// const { txSig } = await this.sendTransaction(initializeTx, [], this.opts);
+
+		await this.accountSubscriber.addSpotMarket(spotMarketIndex);
+		await this.accountSubscriber.addOracle({
+			source: oracleSource,
+			publicKey: oracle,
+		});
+		await this.accountSubscriber.setSpotOracleMap();
+
+		return txSig;
+	}
+
+	public async getInitializeSpotMarketIx(
+		admin: PublicKey,
+		mint: PublicKey,
+		optimalUtilization: number,
+		optimalRate: number,
+		maxRate: number,
+		oracle: PublicKey,
+		oracleSource: OracleSource,
+		initialAssetWeight: number,
+		maintenanceAssetWeight: number,
+		initialLiabilityWeight: number,
+		maintenanceLiabilityWeight: number,
+		imfFactor = 0,
+		liquidatorFee = 0,
+		ifLiquidationFee = 0,
+		activeStatus = true,
+		assetTier = AssetTier.COLLATERAL,
+		scaleInitialAssetWeightStart = ZERO,
+		withdrawGuardThreshold = ZERO,
+		orderTickSize = ONE,
+		orderStepSize = ONE,
+		ifTotalFactor = 0,
+		name = DEFAULT_MARKET_NAME
+	): Promise<TransactionInstruction> {
+		const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
 		const spotMarket = await getSpotMarketPublicKey(
 			this.program.programId,
 			spotMarketIndex
@@ -115,11 +196,18 @@ export class AdminClient extends DriftClient {
 			maintenanceLiabilityWeight,
 			imfFactor,
 			liquidatorFee,
+			ifLiquidationFee,
 			activeStatus,
+			assetTier,
+			scaleInitialAssetWeightStart,
+			withdrawGuardThreshold,
+			orderTickSize,
+			orderStepSize,
+			ifTotalFactor,
 			nameBuffer,
 			{
 				accounts: {
-					admin: this.wallet.publicKey,
+					admin,
 					state: await this.getStatePublicKey(),
 					spotMarket,
 					spotMarketVault,
@@ -134,27 +222,34 @@ export class AdminClient extends DriftClient {
 			}
 		);
 
-		const tx = await this.buildTransaction(initializeIx);
+		return initializeIx;
+	}
 
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+	public async initializeSerumFulfillmentConfig(
+		marketIndex: number,
+		serumMarket: PublicKey,
+		serumProgram: PublicKey
+	): Promise<TransactionSignature> {
+		const initializeIx = await this.getInitializeSerumFulfillmentConfigIx(
+			this.wallet.publicKey,
+			marketIndex,
+			serumMarket,
+			serumProgram
+		);
 
-		// const { txSig } = await this.sendTransaction(initializeTx, [], this.opts);
+		const tx = await this.buildTransaction(initializeIx);
 
-		await this.accountSubscriber.addSpotMarket(spotMarketIndex);
-		await this.accountSubscriber.addOracle({
-			source: oracleSource,
-			publicKey: oracle,
-		});
-		await this.accountSubscriber.setSpotOracleMap();
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 
 		return txSig;
 	}
 
-	public async initializeSerumFulfillmentConfig(
+	public async getInitializeSerumFulfillmentConfigIx(
+		admin: PublicKey,
 		marketIndex: number,
 		serumMarket: PublicKey,
 		serumProgram: PublicKey
-	): Promise<TransactionSignature> {
+	): Promise<TransactionInstruction> {
 		const serumOpenOrders = getSerumOpenOrdersPublicKey(
 			this.program.programId,
 			serumMarket
@@ -165,25 +260,35 @@ export class AdminClient extends DriftClient {
 			serumMarket
 		);
 
-		const initializeIx =
-			await this.program.instruction.initializeSerumFulfillmentConfig(
-				marketIndex,
-				{
-					accounts: {
-						admin: this.wallet.publicKey,
-						state: await this.getStatePublicKey(),
-						baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
-						quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
-						driftSigner: this.getSignerPublicKey(),
-						serumProgram,
-						serumMarket,
-						serumOpenOrders,
-						rent: SYSVAR_RENT_PUBKEY,
-						systemProgram: anchor.web3.SystemProgram.programId,
-						serumFulfillmentConfig,
-					},
-				}
-			);
+		return await this.program.instruction.initializeSerumFulfillmentConfig(
+			marketIndex,
+			{
+				accounts: {
+					admin,
+					state: await this.getStatePublicKey(),
+					baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+					quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
+					driftSigner: this.getSignerPublicKey(),
+					serumProgram,
+					serumMarket,
+					serumOpenOrders,
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					serumFulfillmentConfig,
+				},
+			}
+		);
+	}
+
+	public async initializePhoenixFulfillmentConfig(
+		marketIndex: number,
+		phoenixMarket: PublicKey
+	): Promise<TransactionSignature> {
+		const initializeIx = await this.getInitializePhoenixFulfillmentConfigIx(
+			this.wallet.publicKey,
+			marketIndex,
+			phoenixMarket
+		);
 
 		const tx = await this.buildTransaction(initializeIx);
 
@@ -192,39 +297,33 @@ export class AdminClient extends DriftClient {
 		return txSig;
 	}
 
-	public async initializePhoenixFulfillmentConfig(
+	public async getInitializePhoenixFulfillmentConfigIx(
+		admin: PublicKey,
 		marketIndex: number,
 		phoenixMarket: PublicKey
-	): Promise<TransactionSignature> {
+	): Promise<TransactionInstruction> {
 		const phoenixFulfillmentConfig = getPhoenixFulfillmentConfigPublicKey(
 			this.program.programId,
 			phoenixMarket
 		);
 
-		const initializeIx =
-			await this.program.instruction.initializePhoenixFulfillmentConfig(
-				marketIndex,
-				{
-					accounts: {
-						admin: this.wallet.publicKey,
-						state: await this.getStatePublicKey(),
-						baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
-						quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
-						driftSigner: this.getSignerPublicKey(),
-						phoenixMarket: phoenixMarket,
-						phoenixProgram: PHOENIX_PROGRAM_ID,
-						rent: SYSVAR_RENT_PUBKEY,
-						systemProgram: anchor.web3.SystemProgram.programId,
-						phoenixFulfillmentConfig,
-					},
-				}
-			);
-
-		const tx = await this.buildTransaction(initializeIx);
-
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
-
-		return txSig;
+		return await this.program.instruction.initializePhoenixFulfillmentConfig(
+			marketIndex,
+			{
+				accounts: {
+					admin,
+					state: await this.getStatePublicKey(),
+					baseSpotMarket: this.getSpotMarketAccount(marketIndex).pubkey,
+					quoteSpotMarket: this.getQuoteSpotMarketAccount().pubkey,
+					driftSigner: this.getSignerPublicKey(),
+					phoenixMarket: phoenixMarket,
+					phoenixProgram: PHOENIX_PROGRAM_ID,
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					phoenixFulfillmentConfig,
+				},
+			}
+		);
 	}
 
 	public async initializePerpMarket(
@@ -238,40 +337,52 @@ export class AdminClient extends DriftClient {
 		marginRatioInitial = 2000,
 		marginRatioMaintenance = 500,
 		liquidatorFee = 0,
+		ifLiquidatorFee = 10000,
+		imfFactor = 0,
 		activeStatus = true,
+		baseSpread = 0,
+		maxSpread = 142500,
+		maxOpenInterest = ZERO,
+		maxRevenueWithdrawPerPeriod = ZERO,
+		quoteMaxInsurance = ZERO,
+		orderStepSize = BASE_PRECISION.divn(10000),
+		orderTickSize = PRICE_PRECISION.divn(100000),
+		minOrderSize = BASE_PRECISION.divn(10000),
+		concentrationCoefScale = ONE,
+		curveUpdateIntensity = 0,
+		ammJitIntensity = 0,
 		name = DEFAULT_MARKET_NAME
 	): Promise<TransactionSignature> {
 		const currentPerpMarketIndex = this.getStateAccount().numberOfMarkets;
-		const perpMarketPublicKey = await getPerpMarketPublicKey(
-			this.program.programId,
-			currentPerpMarketIndex
-		);
 
-		const nameBuffer = encodeName(name);
-		const initializeMarketIx =
-			await this.program.instruction.initializePerpMarket(
-				marketIndex,
-				baseAssetReserve,
-				quoteAssetReserve,
-				periodicity,
-				pegMultiplier,
-				oracleSource,
-				marginRatioInitial,
-				marginRatioMaintenance,
-				liquidatorFee,
-				activeStatus,
-				nameBuffer,
-				{
-					accounts: {
-						state: await this.getStatePublicKey(),
-						admin: this.wallet.publicKey,
-						oracle: priceOracle,
-						perpMarket: perpMarketPublicKey,
-						rent: SYSVAR_RENT_PUBKEY,
-						systemProgram: anchor.web3.SystemProgram.programId,
-					},
-				}
-			);
+		const initializeMarketIx = await this.getInitializePerpMarketIx(
+			this.wallet.publicKey,
+			marketIndex,
+			priceOracle,
+			baseAssetReserve,
+			quoteAssetReserve,
+			periodicity,
+			pegMultiplier,
+			oracleSource,
+			marginRatioInitial,
+			marginRatioMaintenance,
+			liquidatorFee,
+			ifLiquidatorFee,
+			imfFactor,
+			activeStatus,
+			baseSpread,
+			maxSpread,
+			maxOpenInterest,
+			maxRevenueWithdrawPerPeriod,
+			quoteMaxInsurance,
+			orderStepSize,
+			orderTickSize,
+			minOrderSize,
+			concentrationCoefScale,
+			curveUpdateIntensity,
+			ammJitIntensity,
+			name
+		);
 		const tx = await this.buildTransaction(initializeMarketIx);
 
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
@@ -290,6 +401,79 @@ export class AdminClient extends DriftClient {
 		return txSig;
 	}
 
+	public async getInitializePerpMarketIx(
+		admin: PublicKey,
+		marketIndex: number,
+		priceOracle: PublicKey,
+		baseAssetReserve: BN,
+		quoteAssetReserve: BN,
+		periodicity: BN,
+		pegMultiplier: BN = PEG_PRECISION,
+		oracleSource: OracleSource = OracleSource.PYTH,
+		marginRatioInitial = 2000,
+		marginRatioMaintenance = 500,
+		liquidatorFee = 0,
+		ifLiquidatorFee = 10000,
+		imfFactor = 0,
+		activeStatus = true,
+		baseSpread = 0,
+		maxSpread = 142500,
+		maxOpenInterest = ZERO,
+		maxRevenueWithdrawPerPeriod = ZERO,
+		quoteMaxInsurance = ZERO,
+		orderStepSize = BASE_PRECISION.divn(10000),
+		orderTickSize = PRICE_PRECISION.divn(100000),
+		minOrderSize = BASE_PRECISION.divn(10000),
+		concentrationCoefScale = ONE,
+		curveUpdateIntensity = 0,
+		ammJitIntensity = 0,
+		name = DEFAULT_MARKET_NAME
+	): Promise<TransactionInstruction> {
+		const currentPerpMarketIndex = this.getStateAccount().numberOfMarkets;
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			currentPerpMarketIndex
+		);
+
+		const nameBuffer = encodeName(name);
+		return await this.program.instruction.initializePerpMarket(
+			marketIndex,
+			baseAssetReserve,
+			quoteAssetReserve,
+			periodicity,
+			pegMultiplier,
+			oracleSource,
+			marginRatioInitial,
+			marginRatioMaintenance,
+			liquidatorFee,
+			ifLiquidatorFee,
+			imfFactor,
+			activeStatus,
+			baseSpread,
+			maxSpread,
+			maxOpenInterest,
+			maxRevenueWithdrawPerPeriod,
+			quoteMaxInsurance,
+			orderStepSize,
+			orderTickSize,
+			minOrderSize,
+			concentrationCoefScale,
+			curveUpdateIntensity,
+			ammJitIntensity,
+			nameBuffer,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					admin,
+					oracle: priceOracle,
+					perpMarket: perpMarketPublicKey,
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+				},
+			}
+		);
+	}
+
 	public async deleteInitializedPerpMarket(
 		marketIndex: number
 	): Promise<TransactionSignature> {
@@ -2172,4 +2356,30 @@ export class AdminClient extends DriftClient {
 
 		return txSig;
 	}
+
+	public async deletePrelaunchOracle(
+		perpMarketIndex: number
+	): Promise<TransactionSignature> {
+		const deletePrelaunchOracleIx =
+			await this.program.instruction.deletePrelaunchOracle(perpMarketIndex, {
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					prelaunchOracle: await getPrelaunchOraclePublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+				},
+			});
+
+		const tx = await this.buildTransaction(deletePrelaunchOracleIx);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
 }

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -0,0 +1,108 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+	Context,
+} from '@solana/web3.js';
+import { BlockhashSubscriberConfig } from './types';
+
+export class BlockhashSubscriber {
+	private connection: Connection;
+	private isSubscribed = false;
+	private latestBlockHeight: number;
+	private latestBlockHeightContext: Context | undefined;
+	private blockhashes: Array<BlockhashWithExpiryBlockHeight> = [];
+	private updateBlockhashIntervalId: NodeJS.Timeout | undefined;
+	private commitment: Commitment;
+	private updateIntervalMs: number;
+
+	constructor(config: BlockhashSubscriberConfig) {
+		if (!config.connection && !config.rpcUrl) {
+			throw new Error(
+				'BlockhashSubscriber requires one of connection or rpcUrl must be provided'
+			);
+		}
+		this.connection = config.connection || new Connection(config.rpcUrl!);
+		this.commitment = config.commitment ?? 'confirmed';
+		this.updateIntervalMs = config.updateIntervalMs ?? 1000;
+	}
+
+	getBlockhashCacheSize(): number {
+		return this.blockhashes.length;
+	}
+
+	getLatestBlockHeight(): number {
+		return this.latestBlockHeight;
+	}
+
+	getLatestBlockHeightContext(): Context | undefined {
+		return this.latestBlockHeightContext;
+	}
+
+	getLatestBlockhash(
+		offset?: number
+	): BlockhashWithExpiryBlockHeight | undefined {
+		if (this.blockhashes.length === 0) {
+			return undefined;
+		}
+		const clampedOffset = Math.max(
+			0,
+			Math.min(this.blockhashes.length - 1, offset ?? 0)
+		);
+
+		return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
+	}
+
+	pruneBlockhashes() {
+		if (this.latestBlockHeight) {
+			this.blockhashes = this.blockhashes.filter(
+				(blockhash) => blockhash.lastValidBlockHeight > this.latestBlockHeight!
+			);
+		}
+	}
+
+	async updateBlockhash() {
+		const [resp, lastConfirmedBlockHeight] = await Promise.all([
+			this.connection.getLatestBlockhashAndContext({
+				commitment: this.commitment,
+			}),
+			this.connection.getBlockHeight({ commitment: this.commitment }),
+		]);
+		this.latestBlockHeight = lastConfirmedBlockHeight;
+		this.latestBlockHeightContext = resp.context;
+
+		// avoid caching duplicate blockhashes
+		if (this.blockhashes.length > 0) {
+			if (
+				resp.value.blockhash ===
+				this.blockhashes[this.blockhashes.length - 1].blockhash
+			) {
+				return;
+			}
+		}
+
+		this.blockhashes.push(resp.value);
+		this.pruneBlockhashes();
+	}
+
+	async subscribe() {
+		if (this.isSubscribed) {
+			return;
+		}
+		this.isSubscribed = true;
+
+		await this.updateBlockhash();
+		this.updateBlockhashIntervalId = setInterval(
+			this.updateBlockhash.bind(this),
+			this.updateIntervalMs
+		);
+	}
+
+	unsubscribe() {
+		if (this.updateBlockhashIntervalId) {
+			clearInterval(this.updateBlockhashIntervalId);
+			this.updateBlockhashIntervalId = undefined;
+		}
+		this.isSubscribed = false;
+	}
+}

package/src/blockhashSubscriber/index.ts

@@ -0,0 +1 @@
+export * from './BlockhashSubscriber';

package/src/blockhashSubscriber/types.ts

@@ -0,0 +1,8 @@
+import { Commitment, Connection } from '@solana/web3.js';
+
+export type BlockhashSubscriberConfig = {
+	rpcUrl?: string;
+	connection?: Connection;
+	commitment?: Commitment;
+	updateIntervalMs?: number;
+};

package/src/dlob/orderBookLevels.ts

@@ -219,6 +219,9 @@ export function getVammL2Generator({
 					);
 
 				baseSwapped = bidAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (baseSwapped.eq(ZERO)) {
+					return;
+				}
 				if (remainingBaseLiquidity.lt(baseSwapped)) {
 					baseSwapped = remainingBaseLiquidity;
 					[afterSwapQuoteReserves, afterSwapBaseReserves] =
@@ -299,6 +302,9 @@ export function getVammL2Generator({
 					);
 
 				baseSwapped = askAmm.baseAssetReserve.sub(afterSwapBaseReserves).abs();
+				if (baseSwapped.eq(ZERO)) {
+					return;
+				}
 				if (remainingBaseLiquidity.lt(baseSwapped)) {
 					baseSwapped = remainingBaseLiquidity;
 					[afterSwapQuoteReserves, afterSwapBaseReserves] =
@@ -423,6 +429,30 @@ function groupL2Levels(
 	return groupedLevels;
 }
 
+/**
+ * Method to merge bids or asks by price
+ */
+const mergeByPrice = (bidsOrAsks: L2Level[]) => {
+	const merged = new Map<string, L2Level>();
+	for (const level of bidsOrAsks) {
+		const key = level.price.toString();
+		if (merged.has(key)) {
+			const existing = merged.get(key);
+			existing.size = existing.size.add(level.size);
+			for (const [source, size] of Object.entries(level.sources)) {
+				if (existing.sources[source]) {
+					existing.sources[source] = existing.sources[source].add(size);
+				} else {
+					existing.sources[source] = size;
+				}
+			}
+		} else {
+			merged.set(key, cloneL2Level(level));
+		}
+	}
+	return Array.from(merged.values());
+};
+
 /**
  * The purpose of this function is uncross the L2 orderbook by modifying the bid/ask price at the top of the book
  * This will make the liquidity look worse but more intuitive (users familiar with clob get confused w temporarily
@@ -461,8 +491,8 @@ export function uncrossL2(
 		return { bids, asks };
 	}
 
-	const newBids = [];
-	const newAsks = [];
+	const newBids: L2Level[] = [];
+	const newAsks: L2Level[] = [];
 
 	const updateLevels = (newPrice: BN, oldLevel: L2Level, levels: L2Level[]) => {
 		if (levels.length > 0 && levels[levels.length - 1].price.eq(newPrice)) {
@@ -522,19 +552,19 @@ export function uncrossL2(
 			continue;
 		}
 
-		if (nextBid.price.gte(nextAsk.price)) {
-			if (userBids.has(nextBid.price.toString())) {
-				newBids.push(nextBid);
-				bidIndex++;
-				continue;
-			}
+		if (userBids.has(nextBid.price.toString())) {
+			newBids.push(nextBid);
+			bidIndex++;
+			continue;
+		}
 
-			if (userAsks.has(nextAsk.price.toString())) {
-				newAsks.push(nextAsk);
-				askIndex++;
-				continue;
-			}
+		if (userAsks.has(nextAsk.price.toString())) {
+			newAsks.push(nextAsk);
+			askIndex++;
+			continue;
+		}
 
+		if (nextBid.price.gte(nextAsk.price)) {
 			if (
 				nextBid.price.gt(referencePrice) &&
 				nextAsk.price.gt(referencePrice)
@@ -588,8 +618,14 @@ export function uncrossL2(
 		}
 	}
 
+	newBids.sort((a, b) => b.price.cmp(a.price));
+	newAsks.sort((a, b) => a.price.cmp(b.price));
+
+	const finalNewBids = mergeByPrice(newBids);
+	const finalNewAsks = mergeByPrice(newAsks);
+
 	return {
-		bids: newBids,
-		asks: newAsks,
+		bids: finalNewBids,
+		asks: finalNewAsks,
 	};
 }