@drift-labs/sdk 2.149.1 → 2.150.0-alpha.0

package/scripts/single-grpc-client-test.ts

@@ -48,9 +48,7 @@ async function initializeSingleGrpcClient() {
 	const allPerpMarketProgramAccounts =
 		(await program.account.perpMarket.all()) as ProgramAccount<PerpMarketAccount>[];
 	const perpMarketProgramAccounts = allPerpMarketProgramAccounts.filter((val) =>
-		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].includes(
-			val.account.marketIndex
-		)
+		[46].includes(val.account.marketIndex)
 	);
 	const perpMarketIndexes = perpMarketProgramAccounts.map(
 		(val) => val.account.marketIndex
@@ -60,7 +58,7 @@ async function initializeSingleGrpcClient() {
 	const allSpotMarketProgramAccounts =
 		(await program.account.spotMarket.all()) as ProgramAccount<SpotMarketAccount>[];
 	const spotMarketProgramAccounts = allSpotMarketProgramAccounts.filter((val) =>
-		[0, 1, 2, 3, 4, 5].includes(val.account.marketIndex)
+		[0].includes(val.account.marketIndex)
 	);
 	const spotMarketIndexes = spotMarketProgramAccounts.map(
 		(val) => val.account.marketIndex
@@ -94,7 +92,9 @@ async function initializeSingleGrpcClient() {
 		}
 	}
 
-	console.log(`📊 Markets: ${perpMarketIndexes.length} perp, ${spotMarketIndexes.length} spot`);
+	console.log(
+		`📊 Markets: ${perpMarketIndexes.length} perp, ${spotMarketIndexes.length} spot`
+	);
 	console.log(`🔮 Oracles: ${oracleInfos.length}`);
 
 
@@ -171,7 +171,9 @@ async function initializeSingleGrpcClient() {
 	await client.subscribe();
 
 	console.log('✅ Client subscribed successfully!');
-	console.log('🚀 Starting high-load testing (50 reads/sec per perp market)...');
+	console.log(
+		'🚀 Starting high-load testing (50 reads/sec per perp market)...'
+	);
 
 	// High-frequency load testing - 50 reads per second per perp market
 	const loadTestInterval = setInterval(async () => {
@@ -179,29 +181,71 @@ async function initializeSingleGrpcClient() {
 			// Test getPerpMarketAccount for each perp market (50 times per second per market)
 			for (const marketIndex of perpMarketIndexes) {
 				const perpMarketAccount = client.getPerpMarketAccount(marketIndex);
-				console.log("perpMarketAccount name: ", decodeName(perpMarketAccount.name));
-				console.log("perpMarketAccount data: ", JSON.stringify({
-					marketIndex: perpMarketAccount.marketIndex,
-					name: decodeName(perpMarketAccount.name),
-					baseAssetReserve: perpMarketAccount.amm.baseAssetReserve.toString(),
-					quoteAssetReserve: perpMarketAccount.amm.quoteAssetReserve.toString()
-				}));
+				if (!perpMarketAccount) {
+					console.log(`Perp market ${marketIndex} not found`);
+					continue;
+				}
+				console.log(
+					'perpMarketAccount name: ',
+					decodeName(perpMarketAccount.name)
+				);
+				console.log(
+					'perpMarketAccount data: ',
+					JSON.stringify({
+						marketIndex: perpMarketAccount.marketIndex,
+						name: decodeName(perpMarketAccount.name),
+						baseAssetReserve: perpMarketAccount.amm.baseAssetReserve.toString(),
+						quoteAssetReserve:
+							perpMarketAccount.amm.quoteAssetReserve.toString(),
+					})
+				);
 			}
 
 			// Test getMMOracleDataForPerpMarket for each perp market (50 times per second per market)
 			for (const marketIndex of perpMarketIndexes) {
 				try {
 					const oracleData = client.getMMOracleDataForPerpMarket(marketIndex);
-					console.log("oracleData price: ", oracleData.price.toString());
-					console.log("oracleData: ", JSON.stringify({
-						price: oracleData.price.toString(),
-						confidence: oracleData.confidence?.toString(),
-						slot: oracleData.slot?.toString()
-					}));
+					console.log('oracleData price: ', oracleData.price.toString());
+					console.log(
+						'oracleData: ',
+						JSON.stringify({
+							price: oracleData.price.toString(),
+							confidence: oracleData.confidence?.toString(),
+							slot: oracleData.slot?.toString(),
+						})
+					);
 				} catch (error) {
 					// Ignore errors for load testing
 				}
 			}
+
+			for (const marketIndex of perpMarketIndexes) {
+				try {
+					const { data, slot } =
+						client.accountSubscriber.getMarketAccountAndSlot(marketIndex);
+					if (!data) {
+						console.log(
+							`Perp market getMarketAccountAndSlot ${marketIndex} not found`
+						);
+						continue;
+					}
+					console.log(
+						'marketAccountAndSlot: ',
+						JSON.stringify({
+							marketIndex: data.marketIndex,
+							name: decodeName(data.name),
+							slot: slot?.toString(),
+							baseAssetReserve: data.amm.baseAssetReserve.toString(),
+							quoteAssetReserve: data.amm.quoteAssetReserve.toString(),
+						})
+					);
+				} catch (error) {
+					console.error(
+						`Error getting market account and slot for market ${marketIndex}:`,
+						error
+					);
+				}
+			}
 		} catch (error) {
 			console.error('Load test error:', error);
 		}
@@ -211,8 +255,14 @@ async function initializeSingleGrpcClient() {
 	const statsInterval = setInterval(() => {
 		console.log('\n📈 Event Counts:', eventCounts);
 		console.log(`⏱️  Client subscribed: ${client.isSubscribed}`);
-		console.log(`🔗 Account subscriber subscribed: ${client.accountSubscriber.isSubscribed}`);
-		console.log(`🔥 Load: ${perpMarketIndexes.length * 50 * 2} reads/sec (${perpMarketIndexes.length} markets × 50 getPerpMarketAccount + 50 getMMOracleDataForPerpMarket)`);
+		console.log(
+			`🔗 Account subscriber subscribed: ${client.accountSubscriber.isSubscribed}`
+		);
+		console.log(
+			`🔥 Load: ${perpMarketIndexes.length * 50 * 2} reads/sec (${
+				perpMarketIndexes.length
+			} markets × 50 getPerpMarketAccount + 50 getMMOracleDataForPerpMarket)`
+		);
 	}, 5000);
 
 	// Handle shutdown signals - just exit without cleanup since they never unsubscribe

package/scripts/withdraw-isolated-positions.ts

@@ -0,0 +1,174 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import dotenv from 'dotenv';
+import {
+	AnchorProvider,
+	Idl,
+	Program,
+	ProgramAccount,
+} from '@coral-xyz/anchor';
+import driftIDL from '../src/idl/drift.json';
+import {
+	DRIFT_PROGRAM_ID,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	OracleInfo,
+	Wallet,
+	ZERO,
+} from '../src';
+import { DriftClient } from '../src/driftClient';
+import { DriftClientConfig } from '../src/driftClientConfig';
+
+function isStatusOpen(status: any) {
+	return !!status && 'open' in status;
+}
+
+function isPerpMarketType(marketType: any) {
+	return !!marketType && 'perp' in marketType;
+}
+
+async function main() {
+	dotenv.config({ path: '../' });
+
+	const RPC_ENDPOINT = process.env.RPC_ENDPOINT;
+	if (!RPC_ENDPOINT) throw new Error('RPC_ENDPOINT env var required');
+
+	// Load wallet
+	// For safety this creates a new ephemeral wallet unless PRIVATE_KEY is provided (base58 array)
+	let keypair: Keypair;
+	const pk = process.env.PRIVATE_KEY;
+	if (pk) {
+		const secret = Uint8Array.from(JSON.parse(pk));
+		keypair = Keypair.fromSecretKey(secret);
+	} else {
+		keypair = new Keypair();
+		console.warn(
+			'Using ephemeral keypair. Provide PRIVATE_KEY for real withdrawals.'
+		);
+	}
+	const wallet = new Wallet(keypair);
+
+	// Connection and program for market discovery
+	const connection = new Connection(RPC_ENDPOINT);
+	const provider = new AnchorProvider(connection, wallet as any, {
+		commitment: 'processed',
+	});
+	const programId = new PublicKey(DRIFT_PROGRAM_ID);
+	const program = new Program(driftIDL as Idl, programId, provider);
+
+	// Discover markets and oracles (like the example test script)
+	const allPerpMarketProgramAccounts =
+		(await program.account.perpMarket.all()) as ProgramAccount<PerpMarketAccount>[];
+	const perpMarketIndexes = allPerpMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
+	);
+	const allSpotMarketProgramAccounts =
+		(await program.account.spotMarket.all()) as ProgramAccount<SpotMarketAccount>[];
+	const spotMarketIndexes = allSpotMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
+	);
+
+	const seen = new Set<string>();
+	const oracleInfos: OracleInfo[] = [];
+	for (const acct of allPerpMarketProgramAccounts) {
+		const key = `${acct.account.amm.oracle.toBase58()}-${
+			Object.keys(acct.account.amm.oracleSource)[0]
+		}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			oracleInfos.push({
+				publicKey: acct.account.amm.oracle,
+				source: acct.account.amm.oracleSource,
+			});
+		}
+	}
+	for (const acct of allSpotMarketProgramAccounts) {
+		const key = `${acct.account.oracle.toBase58()}-${
+			Object.keys(acct.account.oracleSource)[0]
+		}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			oracleInfos.push({
+				publicKey: acct.account.oracle,
+				source: acct.account.oracleSource,
+			});
+		}
+	}
+
+	// Build DriftClient with websocket subscription (lightweight)
+	const clientConfig: DriftClientConfig = {
+		connection,
+		wallet,
+		programID: programId,
+		accountSubscription: {
+			type: 'websocket',
+			commitment: 'processed',
+		},
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
+		env: 'devnet',
+	};
+	const client = new DriftClient(clientConfig);
+	await client.subscribe();
+
+	// Ensure user exists and is subscribed
+	const user = client.getUser();
+	await user.subscribe();
+
+	const userAccount = user.getUserAccount();
+	const openOrders = user.getOpenOrders();
+
+	const marketsWithOpenOrders = new Set<number>();
+	for (const o of openOrders ?? []) {
+		if (isStatusOpen(o.status) && isPerpMarketType(o.marketType)) {
+			marketsWithOpenOrders.add(o.marketIndex);
+		}
+	}
+
+	const withdrawTargets = userAccount.perpPositions.filter((pos) => {
+		const isZeroBase = pos.baseAssetAmount.eq(ZERO);
+		const hasIso = pos.isolatedPositionScaledBalance.gt(ZERO);
+		const hasOpenOrders = marketsWithOpenOrders.has(pos.marketIndex);
+		return isZeroBase && hasIso && !hasOpenOrders;
+	});
+
+	console.log(
+		`Found ${withdrawTargets.length} isolated perp positions to withdraw`
+	);
+
+	for (const pos of withdrawTargets) {
+		try {
+			const amount = client.getIsolatedPerpPositionTokenAmount(pos.marketIndex);
+			if (amount.lte(ZERO)) continue;
+
+			const perpMarketAccount = client.getPerpMarketAccount(pos.marketIndex);
+			const quoteAta = await client.getAssociatedTokenAccount(
+				perpMarketAccount.quoteSpotMarketIndex
+			);
+
+			const ixs = await client.getWithdrawFromIsolatedPerpPositionIxsBundle(
+				amount,
+				pos.marketIndex,
+				0,
+				quoteAta,
+				true
+			);
+
+			const tx = await client.buildTransaction(ixs);
+			const { txSig } = await client.sendTransaction(tx);
+			console.log(
+				`Withdrew isolated deposit for perp market ${pos.marketIndex}: ${txSig}`
+			);
+		} catch (e) {
+			console.error(`Failed to withdraw for market ${pos.marketIndex}:`, e);
+		}
+	}
+
+	await user.unsubscribe();
+	await client.unsubscribe();
+}
+
+main().catch((e) => {
+	console.error(e);
+	process.exit(1);
+});

package/src/constants/perpMarkets.ts

@@ -1428,6 +1428,17 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		oracleSource: OracleSource.PYTH_LAZER,
 		pythLazerId: 2382,
 	},
+	{
+		fullName: 'Monad',
+		category: ['L1'],
+		symbol: '1KMON-PERP',
+		baseAssetSymbol: '1KMON',
+		marketIndex: 83,
+		oracle: new PublicKey('585jsthKg9BeTfnFGAxgfNie9krGGyPbd5feMpWneHf7'),
+		launchTs: 1763996757000,
+		oracleSource: OracleSource.PYTH_LAZER_1K,
+		pythLazerId: 2396,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/constants/spotMarkets.ts

@@ -993,6 +993,20 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		pythLazerId: 2382,
 		launchTs: 1761225524000,
 	},
+	{
+		symbol: 'CASH',
+		marketIndex: 61,
+		poolId: 0,
+		oracle: new PublicKey('AK6coxSjfAnuDT4ZUSP3UpeQe2G1tKcALnsdd835eg7T'),
+		oracleSource: OracleSource.PYTH_LAZER_STABLE_COIN,
+		mint: new PublicKey('CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH'),
+		precision: new BN(10).pow(SIX),
+		precisionExp: SIX,
+		pythFeedId:
+			'0xdf3320ef0f4617337b8dbb924f2aaa4f9db08f522a5435b44f9066c1ac4c7f95',
+		pythLazerId: 2323,
+		launchTs: 1763677264000,
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/decode/user.ts

@@ -84,7 +84,7 @@ export function decodeUser(buffer: Buffer): UserAccount {
 		const quoteAssetAmount = readSignedBigInt64LE(buffer, offset + 16);
 		const lpShares = readUnsignedBigInt64LE(buffer, offset + 64);
 		const openOrders = buffer.readUInt8(offset + 94);
-		const positionFlag = buffer.readUInt8(offset + 95);
+		const positionFlag = 0;
 		const isolatedPositionScaledBalance = readUnsignedBigInt64LE(
 			buffer,
 			offset + 96
@@ -122,7 +122,6 @@ export function decodeUser(buffer: Buffer): UserAccount {
 		offset += 3;
 		const perLpBase = buffer.readUInt8(offset);
 		offset += 1;
-
 		perpPositions.push({
 			lastCumulativeFundingRate,
 			baseAssetAmount,
@@ -140,8 +139,8 @@ export function decodeUser(buffer: Buffer): UserAccount {
 			openOrders,
 			perLpBase,
 			maxMarginRatio,
-			isolatedPositionScaledBalance,
 			positionFlag,
+			isolatedPositionScaledBalance,
 		});
 	}