@drift-labs/sdk 2.142.0-beta.8 → 2.142.0

package/scripts/client-test.ts

@@ -1,12 +1,14 @@
 import { DriftClient } from '../src/driftClient';
 import { grpcDriftClientAccountSubscriberV2 } from '../src/accounts/grpcDriftClientAccountSubscriberV2';
+import { grpcDriftClientAccountSubscriber } from '../src/accounts/grpcDriftClientAccountSubscriber';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import { DriftClientConfig } from '../src/driftClientConfig';
 import {
-	decodeName,
 	DRIFT_PROGRAM_ID,
 	PerpMarketAccount,
+	SpotMarketAccount,
 	Wallet,
+	OracleInfo,
 } from '../src';
 import { CommitmentLevel } from '@triton-one/yellowstone-grpc';
 import dotenv from 'dotenv';
@@ -17,12 +19,14 @@ import {
 	ProgramAccount,
 } from '@coral-xyz/anchor';
 import driftIDL from '../src/idl/drift.json';
+import assert from 'assert';
 
 const GRPC_ENDPOINT = process.env.GRPC_ENDPOINT;
 const TOKEN = process.env.TOKEN;
+const RPC_ENDPOINT = process.env.RPC_ENDPOINT;
 
-async function initializeGrpcDriftClientV2() {
-	const connection = new Connection('https://api.mainnet-beta.solana.com');
+async function initializeGrpcDriftClientV2VersusV1() {
+	const connection = new Connection(RPC_ENDPOINT);
 	const wallet = new Wallet(new Keypair());
 	dotenv.config({ path: '../' });
 
@@ -32,174 +36,338 @@ async function initializeGrpcDriftClientV2() {
 		// @ts-ignore
 		wallet,
 		{
-			commitment: 'confirmed',
+			commitment: 'processed',
 		}
 	);
 
 	const program = new Program(driftIDL as Idl, programId, provider);
 
-	const perpMarketProgramAccounts =
+	const allPerpMarketProgramAccounts =
 		(await program.account.perpMarket.all()) as ProgramAccount<PerpMarketAccount>[];
-	const solPerpMarket = perpMarketProgramAccounts.find(
-		(account) => account.account.marketIndex === 0
+	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
+		)
 	);
-	const solOracleInfo = {
-		publicKey: solPerpMarket.account.amm.oracle,
-		source: solPerpMarket.account.amm.oracleSource,
-	};
-	const ethPerpMarket = perpMarketProgramAccounts.find(
-		(account) => account.account.marketIndex === 2
+	const perpMarketIndexes = perpMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
 	);
-	const ethOracleInfo = {
-		publicKey: ethPerpMarket.account.amm.oracle,
-		source: ethPerpMarket.account.amm.oracleSource,
-	};
-	const btcPerpMarket = perpMarketProgramAccounts.find(
-		(account) => account.account.marketIndex === 1
+
+	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)
 	);
-	const btcOracleInfo = {
-		publicKey: btcPerpMarket.account.amm.oracle,
-		source: btcPerpMarket.account.amm.oracleSource,
+	const spotMarketIndexes = spotMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
+	);
+
+	const seen = new Set<string>();
+	const oracleInfos: OracleInfo[] = [];
+	for (const acct of perpMarketProgramAccounts) {
+		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 spotMarketProgramAccounts) {
+		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,
+			});
+		}
+	}
+
+	const baseAccountSubscription = {
+		type: 'grpc' as const,
+		grpcConfigs: {
+			endpoint: GRPC_ENDPOINT,
+			token: TOKEN,
+			commitmentLevel: CommitmentLevel.PROCESSED,
+			channelOptions: {
+				'grpc.keepalive_time_ms': 10_000,
+				'grpc.keepalive_timeout_ms': 1_000,
+				'grpc.keepalive_permit_without_calls': 1,
+			},
+		},
 	};
 
-	const config: DriftClientConfig = {
+	const configV2: DriftClientConfig = {
 		connection,
 		wallet,
 		programID: new PublicKey(DRIFT_PROGRAM_ID),
 		accountSubscription: {
-			type: 'grpc',
-			grpcConfigs: {
-				endpoint: GRPC_ENDPOINT,
-				token: TOKEN,
-				commitmentLevel: 'confirmed' as unknown as CommitmentLevel,
-				channelOptions: {
-					'grpc.keepalive_time_ms': 10_000,
-					'grpc.keepalive_timeout_ms': 1_000,
-					'grpc.keepalive_permit_without_calls': 1,
-				},
-			},
+			...baseAccountSubscription,
 			driftClientAccountSubscriber: grpcDriftClientAccountSubscriberV2,
 		},
-		perpMarketIndexes: [0, 1, 2],
-		spotMarketIndexes: [0, 1, 2],
-		oracleInfos: [solOracleInfo, ethOracleInfo, btcOracleInfo],
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
 	};
 
-	const driftClient = new DriftClient(config);
+	const configV1: DriftClientConfig = {
+		connection,
+		wallet,
+		programID: new PublicKey(DRIFT_PROGRAM_ID),
+		accountSubscription: {
+			...baseAccountSubscription,
+			driftClientAccountSubscriber: grpcDriftClientAccountSubscriber,
+		},
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
+	};
 
-	let perpMarketUpdateCount = 0;
-	let spotMarketUpdateCount = 0;
-	let oraclePriceUpdateCount = 0;
-	let userAccountUpdateCount = 0;
+	const clientV2 = new DriftClient(configV2);
+	const clientV1 = new DriftClient(configV1);
 
-	const updatePromise = new Promise<void>((resolve) => {
-		driftClient.accountSubscriber.eventEmitter.on(
-			'perpMarketAccountUpdate',
-			(data) => {
-				console.log('Perp market account update:', decodeName(data.name));
-				const perpMarketData = driftClient.getPerpMarketAccount(
-					data.marketIndex
-				);
-				console.log(
-					'Perp market data market index:',
-					perpMarketData?.marketIndex
+	await Promise.all([clientV1.subscribe(), clientV2.subscribe()]);
+	const compare = () => {
+		try {
+			// 1. Test getStateAccountAndSlot
+			const state1 = clientV1.accountSubscriber.getStateAccountAndSlot();
+			const state2 = clientV2.accountSubscriber.getStateAccountAndSlot();
+			assert.deepStrictEqual(
+				state1.data,
+				state2.data,
+				'State accounts should match'
+			);
+			if (
+				state1.slot !== undefined &&
+				state2.slot !== undefined &&
+				state2.slot < state1.slot
+			) {
+				console.error(
+					`State account slot regression: v2 slot ${state2.slot} < v1 slot ${state1.slot}`
 				);
-				const oracle = driftClient.getOracleDataForPerpMarket(data.marketIndex);
-				const mmOracle = driftClient.getMMOracleDataForPerpMarket(
-					data.marketIndex
+			}
+
+			// 2. Test getMarketAccountsAndSlots (all perp markets) - sorted comparison
+			const allPerpMarkets1 = clientV1.accountSubscriber
+				.getMarketAccountsAndSlots()
+				.sort((a, b) => a.data.marketIndex - b.data.marketIndex);
+			const allPerpMarkets2 = clientV2.accountSubscriber
+				.getMarketAccountsAndSlots()
+				.sort((a, b) => a.data.marketIndex - b.data.marketIndex);
+			assert.strictEqual(
+				allPerpMarkets1.length,
+				allPerpMarkets2.length,
+				'Number of perp markets should match'
+			);
+
+			// Compare each perp market in the sorted arrays
+			for (let i = 0; i < allPerpMarkets1.length; i++) {
+				const market1 = allPerpMarkets1[i];
+				const market2 = allPerpMarkets2[i];
+				assert.strictEqual(
+					market1.data.marketIndex,
+					market2.data.marketIndex,
+					`Perp market at position ${i} should have same marketIndex`
 				);
-				console.log('Perp oracle price:', oracle.price.toString());
-				console.log('Perp MM oracle price:', mmOracle.price.toString());
-				perpMarketUpdateCount++;
+				// assert.deepStrictEqual(
+				// 	market1.data,
+				// 	market2.data,
+				// 	`Perp market ${market1.data.marketIndex} (from getMarketAccountsAndSlots) should match`
+				// );
+			}
+
+			// 3. Test getMarketAccountAndSlot for each perp market
+			for (const idx of perpMarketIndexes) {
+				const market1 = clientV1.accountSubscriber.getMarketAccountAndSlot(idx);
+				const market2 = clientV2.accountSubscriber.getMarketAccountAndSlot(idx);
+				// assert.deepStrictEqual(
+				// 	market1?.data,
+				// 	market2?.data,
+				// 	`Perp market ${idx} data should match`
+				// );
+				// assert.strictEqual(
+				// 	market1?.slot,
+				// 	market2?.slot,
+				// 	`Perp market ${idx} slot should match`
+				// );
 				if (
-					perpMarketUpdateCount >= 10 &&
-					spotMarketUpdateCount >= 10 &&
-					oraclePriceUpdateCount >= 10 &&
-					userAccountUpdateCount >= 2
+					market1?.slot !== undefined &&
+					market2?.slot !== undefined &&
+					market2.slot < market1.slot
 				) {
-					resolve();
+					console.error(
+						`Perp market ${idx} slot regression: v2 slot ${market2.slot} < v1 slot ${market1.slot}`
+					);
+				} else if (
+					market1?.slot !== undefined &&
+					market2?.slot !== undefined &&
+					market2.slot > market1.slot
+				) {
+					console.info(
+						`Perp market ${idx} slot is FASTER! v2: ${market2.slot}, v1: ${market1.slot}`
+					);
 				}
 			}
-		);
-
-		driftClient.accountSubscriber.eventEmitter.on(
-			'spotMarketAccountUpdate',
-			(data) => {
-				console.log('Spot market account update:', decodeName(data.name));
-				const spotMarketData = driftClient.getSpotMarketAccount(
-					data.marketIndex
-				);
-				console.log(
-					'Spot market data market index:',
-					spotMarketData?.marketIndex
+
+			// 4. Test getSpotMarketAccountsAndSlots (all spot markets) - sorted comparison
+			const allSpotMarkets1 = clientV1.accountSubscriber
+				.getSpotMarketAccountsAndSlots()
+				.sort((a, b) => a.data.marketIndex - b.data.marketIndex);
+			const allSpotMarkets2 = clientV2.accountSubscriber
+				.getSpotMarketAccountsAndSlots()
+				.sort((a, b) => a.data.marketIndex - b.data.marketIndex);
+			assert.strictEqual(
+				allSpotMarkets1.length,
+				allSpotMarkets2.length,
+				'Number of spot markets should match'
+			);
+
+			// Compare each spot market in the sorted arrays
+			for (let i = 0; i < allSpotMarkets1.length; i++) {
+				const market1 = allSpotMarkets1[i];
+				const market2 = allSpotMarkets2[i];
+				assert.strictEqual(
+					market1.data.marketIndex,
+					market2.data.marketIndex,
+					`Spot market at position ${i} should have same marketIndex`
 				);
-				const oracle = driftClient.getOracleDataForSpotMarket(data.marketIndex);
-				console.log('Spot oracle price:', oracle.price.toString());
-				spotMarketUpdateCount++;
+				// assert.deepStrictEqual(
+				// 	market1.data,
+				// 	market2.data,
+				// 	`Spot market ${market1.data.marketIndex} (from getSpotMarketAccountsAndSlots) should match`
+				// );
+			}
+
+			// 5. Test getSpotMarketAccountAndSlot for each spot market
+			for (const idx of spotMarketIndexes) {
+				const market1 =
+					clientV1.accountSubscriber.getSpotMarketAccountAndSlot(idx);
+				const market2 =
+					clientV2.accountSubscriber.getSpotMarketAccountAndSlot(idx);
+				// assert.deepStrictEqual(
+				// 	market1?.data,
+				// 	market2?.data,
+				// 	`Spot market ${idx} data should match`
+				// );
+				// assert.strictEqual(
+				// 	market1?.slot,
+				// 	market2?.slot,
+				// 	`Spot market ${idx} slot should match`
+				// );
 				if (
-					perpMarketUpdateCount >= 10 &&
-					spotMarketUpdateCount >= 10 &&
-					oraclePriceUpdateCount >= 10 &&
-					userAccountUpdateCount >= 2
+					market1?.slot !== undefined &&
+					market2?.slot !== undefined &&
+					market2.slot < market1.slot
+				) {
+					console.error(
+						`Spot market ${idx} slot regression: v2 slot ${market2.slot} < v1 slot ${market1.slot}`
+					);
+				} else if (
+					market1?.slot !== undefined &&
+					market2?.slot !== undefined &&
+					market2.slot > market1.slot
 				) {
-					resolve();
+					console.info(
+						`Spot market ${idx} slot is FASTER! v2: ${market2.slot}, v1: ${market1.slot}`
+					);
 				}
 			}
-		);
 
-		driftClient.accountSubscriber.eventEmitter.on(
-			'oraclePriceUpdate',
-			(data) => {
-				console.log('Oracle price update:', data.toBase58());
-				oraclePriceUpdateCount++;
+			// 6. Test getOraclePriceDataAndSlotForPerpMarket
+			for (const idx of perpMarketIndexes) {
+				const oracle1 =
+					clientV1.accountSubscriber.getOraclePriceDataAndSlotForPerpMarket(
+						idx
+					);
+				const oracle2 =
+					clientV2.accountSubscriber.getOraclePriceDataAndSlotForPerpMarket(
+						idx
+					);
+				// assert.deepStrictEqual(
+				// 	oracle1?.data,
+				// 	oracle2?.data,
+				// 	`Perp market ${idx} oracle data should match`
+				// );
+				// Note: slots might differ slightly due to timing, so we can optionally skip this check or be lenient
+				// assert.strictEqual(oracle1?.slot, oracle2?.slot, `Perp market ${idx} oracle slot should match`);
 				if (
-					perpMarketUpdateCount >= 10 &&
-					spotMarketUpdateCount >= 10 &&
-					oraclePriceUpdateCount >= 10 &&
-					userAccountUpdateCount >= 2
+					oracle1?.slot !== undefined &&
+					oracle2?.slot !== undefined &&
+					oracle2.slot < oracle1.slot
+				) {
+					console.error(
+						`Perp market ${idx} oracle slot regression: v2 slot ${oracle2.slot} < v1 slot ${oracle1.slot}`
+					);
+				} else if (
+					oracle1?.slot !== undefined &&
+					oracle2?.slot !== undefined &&
+					oracle2.slot > oracle1.slot
 				) {
-					resolve();
+					console.info(
+						`Perp market ${idx} oracle slot is FASTER! v2: ${oracle2.slot}, v1: ${oracle1.slot}`
+					);
 				}
 			}
-		);
 
-		driftClient.accountSubscriber.eventEmitter.on(
-			'userAccountUpdate',
-			(data) => {
-				console.log('User account update:', decodeName(data.name));
-				userAccountUpdateCount++;
+			// 7. Test getOraclePriceDataAndSlotForSpotMarket
+			for (const idx of spotMarketIndexes) {
+				const oracle1 =
+					clientV1.accountSubscriber.getOraclePriceDataAndSlotForSpotMarket(
+						idx
+					);
+				const oracle2 =
+					clientV2.accountSubscriber.getOraclePriceDataAndSlotForSpotMarket(
+						idx
+					);
+				// assert.deepStrictEqual(
+				// 	oracle1?.data,
+				// 	oracle2?.data,
+				// 	`Spot market ${idx} oracle data should match`
+				// );
+				// Note: slots might differ slightly due to timing
+				// assert.strictEqual(oracle1?.slot, oracle2?.slot, `Spot market ${idx} oracle slot should match`);
 				if (
-					perpMarketUpdateCount >= 10 &&
-					spotMarketUpdateCount >= 10 &&
-					oraclePriceUpdateCount >= 10 &&
-					userAccountUpdateCount >= 2
+					oracle1?.slot !== undefined &&
+					oracle2?.slot !== undefined &&
+					oracle2.slot < oracle1.slot
 				) {
-					resolve();
+					console.error(
+						`Spot market ${idx} oracle slot regression: v2 slot ${oracle2.slot} < v1 slot ${oracle1.slot}`
+					);
+				} else if (
+					oracle1?.slot !== undefined &&
+					oracle2?.slot !== undefined &&
+					oracle2.slot > oracle1.slot
+				) {
+					console.info(
+						`Spot market ${idx} oracle slot is FASTER! v2: ${oracle2.slot}, v1: ${oracle1.slot}`
+					);
 				}
 			}
-		);
-	});
-
-	await driftClient.subscribe();
-	console.log('DriftClient initialized and listening for updates.');
 
-	for (const marketIndex of config.perpMarketIndexes) {
-		const oracle = driftClient.getOracleDataForPerpMarket(marketIndex);
-		const mmOracle = driftClient.getMMOracleDataForPerpMarket(marketIndex);
-		console.log('Initial perp oracle price:', oracle.price.toString());
-		console.log('Initial perp MM oracle price:', mmOracle.price.toString());
-	}
+			console.log('✓ All comparisons passed');
+		} catch (error) {
+			console.error('✗ Comparison failed:', error);
+		}
+	};
 
-	for (const marketIndex of config.spotMarketIndexes) {
-		const oracle = driftClient.getOracleDataForSpotMarket(marketIndex);
-		console.log('Initial spot oracle price:', oracle.price.toString());
-	}
+	compare();
+	const interval = setInterval(compare, 1000);
 
-	const stateAccount = driftClient.getStateAccount();
-	console.log('Initial state account:', stateAccount.toString());
+	const cleanup = async () => {
+		clearInterval(interval);
+		await Promise.all([clientV1.unsubscribe(), clientV2.unsubscribe()]);
+		process.exit(0);
+	};
 
-	await updatePromise;
-	console.log('Received required number of updates.');
+	process.on('SIGINT', cleanup);
+	process.on('SIGTERM', cleanup);
 }
 
-initializeGrpcDriftClientV2().catch(console.error);
+initializeGrpcDriftClientV2VersusV1().catch(console.error);