@velocity-exchange/sdk 0.0.1

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

@@ -0,0 +1,372 @@
+import { VelocityClient } from '../src/velocityClient';
+import { grpcVelocityClientAccountSubscriberV2 } from '../src/accounts/grpcVelocityClientAccountSubscriberV2';
+import { grpcVelocityClientAccountSubscriber } from '../src/accounts/grpcVelocityClientAccountSubscriber';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { VelocityClientConfig } from '../src/velocityClientConfig';
+import {
+	VELOCITY_PROGRAM_ID,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	Wallet,
+	OracleInfo,
+} from '../src';
+import { CommitmentLevel } from '@triton-one/yellowstone-grpc';
+import dotenv from 'dotenv';
+import {
+	AnchorProvider,
+	Idl,
+	Program,
+	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 initializeGrpcDriftClientV2VersusV1() {
+	const connection = new Connection(RPC_ENDPOINT);
+	const wallet = new Wallet(new Keypair());
+	dotenv.config({ path: '../' });
+
+	const programId = new PublicKey(VELOCITY_PROGRAM_ID);
+	const provider = new AnchorProvider(
+		connection,
+		// @ts-ignore
+		wallet,
+		{
+			commitment: 'processed',
+		}
+	);
+
+	const program = new Program(driftIDL as Idl, programId, provider);
+
+	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
+		)
+	);
+	const perpMarketIndexes = perpMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
+	);
+
+	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 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: {
+				grpcKeepAliveTimeout: 1_000,
+				grpcTcpKeepalive: 10_000,
+			},
+		},
+	};
+
+	const configV2: VelocityClientConfig = {
+		connection,
+		wallet,
+		programID: new PublicKey(VELOCITY_PROGRAM_ID),
+		accountSubscription: {
+			...baseAccountSubscription,
+			velocityClientAccountSubscriber: grpcVelocityClientAccountSubscriberV2,
+		},
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
+	};
+
+	const configV1: VelocityClientConfig = {
+		connection,
+		wallet,
+		programID: new PublicKey(VELOCITY_PROGRAM_ID),
+		accountSubscription: {
+			...baseAccountSubscription,
+			velocityClientAccountSubscriber: grpcVelocityClientAccountSubscriber,
+		},
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
+	};
+
+	const clientV2 = new VelocityClient(configV2);
+	const clientV1 = new VelocityClient(configV1);
+
+	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}`
+				);
+			}
+
+			// 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`
+				);
+				// 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 (
+					market1?.slot !== undefined &&
+					market2?.slot !== undefined &&
+					market2.slot < market1.slot
+				) {
+					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}`
+					);
+				}
+			}
+
+			// 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`
+				);
+				// 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 (
+					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
+				) {
+					console.info(
+						`Spot market ${idx} slot is FASTER! v2: ${market2.slot}, v1: ${market1.slot}`
+					);
+				}
+			}
+
+			// 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 (
+					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
+				) {
+					console.info(
+						`Perp market ${idx} oracle slot is FASTER! v2: ${oracle2.slot}, v1: ${oracle1.slot}`
+					);
+				}
+			}
+
+			// 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 (
+					oracle1?.slot !== undefined &&
+					oracle2?.slot !== undefined &&
+					oracle2.slot < oracle1.slot
+				) {
+					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}`
+					);
+				}
+			}
+
+			console.log('✓ All comparisons passed');
+		} catch (error) {
+			console.error('✗ Comparison failed:', error);
+		}
+	};
+
+	compare();
+	const interval = setInterval(compare, 1000);
+
+	const cleanup = async () => {
+		clearInterval(interval);
+		await Promise.all([clientV1.unsubscribe(), clientV2.unsubscribe()]);
+		process.exit(0);
+	};
+
+	process.on('SIGINT', cleanup);
+	process.on('SIGTERM', cleanup);
+}
+
+initializeGrpcDriftClientV2VersusV1().catch(console.error);

package/scripts/grpc-multiuser-client-test-comparison.ts

@@ -0,0 +1,158 @@
+import { grpcUserAccountSubscriber } from '../src/accounts/grpcUserAccountSubscriber';
+import { grpcMultiUserAccountSubscriber } from '../src/accounts/grpcMultiUserAccountSubscriber';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { VELOCITY_PROGRAM_ID } from '../src';
+import { CommitmentLevel } from '@triton-one/yellowstone-grpc';
+import { AnchorProvider, Idl, Program } from '@coral-xyz/anchor';
+import driftIDL from '../src/idl/drift.json';
+import assert from 'assert';
+import { Wallet } from '../src';
+
+const GRPC_ENDPOINT = process.env.GRPC_ENDPOINT;
+const TOKEN = process.env.TOKEN;
+const RPC_ENDPOINT = process.env.RPC_ENDPOINT;
+
+const USER_ACCOUNT_PUBKEYS = [
+	// Add user account public keys here, e.g.:
+	// new PublicKey('...')
+];
+
+async function testGrpcUserAccountSubscriberV1VsV2() {
+	console.log('🚀 Initializing User Account Subscriber V1 vs V2 Test...');
+
+	if (USER_ACCOUNT_PUBKEYS.length === 0) {
+		console.error(
+			'❌ No user account public keys provided. Please add some to USER_ACCOUNT_PUBKEYS array.'
+		);
+		process.exit(1);
+	}
+
+	const connection = new Connection(RPC_ENDPOINT);
+	const wallet = new Wallet(new Keypair());
+
+	const programId = new PublicKey(VELOCITY_PROGRAM_ID);
+	const provider = new AnchorProvider(
+		connection,
+		// @ts-ignore
+		wallet,
+		{
+			commitment: 'processed',
+		}
+	);
+
+	const program = new Program(driftIDL as Idl, programId, provider);
+
+	const grpcConfigs = {
+		endpoint: GRPC_ENDPOINT,
+		token: TOKEN,
+		commitmentLevel: CommitmentLevel.PROCESSED,
+		channelOptions: {
+			grpcKeepAliveTimeout: 1_000,
+			grpcTcpKeepalive: 10_000,
+		},
+	};
+
+	console.log(`📊 Testing ${USER_ACCOUNT_PUBKEYS.length} user accounts...`);
+
+	// V1: Create individual subscribers for each user account
+	const v1Subscribers = USER_ACCOUNT_PUBKEYS.map(
+		(pubkey) =>
+			new grpcUserAccountSubscriber(grpcConfigs, program, pubkey, {
+				logResubMessages: true,
+			})
+	);
+
+	// V2: Create a single multi-subscriber and get per-user interfaces
+	const v2MultiSubscriber = new grpcMultiUserAccountSubscriber(
+		program,
+		grpcConfigs,
+		{ logResubMessages: true }
+	);
+	const v2Subscribers = USER_ACCOUNT_PUBKEYS.map((pubkey) =>
+		v2MultiSubscriber.forUser(pubkey)
+	);
+
+	// Subscribe all V1 subscribers
+	console.log('🔗 Subscribing V1 subscribers...');
+	await Promise.all(v1Subscribers.map((sub) => sub.subscribe()));
+	console.log('✅ V1 subscribers ready');
+
+	// Subscribe all V2 subscribers
+	console.log('🔗 Subscribing V2 subscribers...');
+	await v2MultiSubscriber.subscribe();
+	console.log('✅ V2 subscribers ready');
+
+	const compare = () => {
+		try {
+			let passedTests = 0;
+			let totalTests = 0;
+
+			// Test each user account
+			for (let i = 0; i < USER_ACCOUNT_PUBKEYS.length; i++) {
+				const pubkey = USER_ACCOUNT_PUBKEYS[i];
+				const v1Sub = v1Subscribers[i];
+				const v2Sub = v2Subscribers[i];
+
+				totalTests++;
+
+				// 1. Test isSubscribed
+				assert.strictEqual(
+					v1Sub.isSubscribed,
+					v2Sub.isSubscribed,
+					`User ${pubkey.toBase58()}: isSubscribed should match`
+				);
+
+				// 2. Test getUserAccountAndSlot
+				const v1Data = v1Sub.getUserAccountAndSlot();
+				const v2Data = v2Sub.getUserAccountAndSlot();
+
+				// Compare the user account data
+				assert.deepStrictEqual(
+					v1Data.data,
+					v2Data.data,
+					`User ${pubkey.toBase58()}: account data should match`
+				);
+
+				// Slots might differ slightly due to timing, but let's check if they're close
+				const slotDiff = Math.abs(v1Data.slot - v2Data.slot);
+				if (slotDiff > 10) {
+					console.warn(
+						`⚠️  User ${pubkey.toBase58()}: slot difference is ${slotDiff} (v1: ${
+							v1Data.slot
+						}, v2: ${v2Data.slot})`
+					);
+				}
+
+				passedTests++;
+			}
+
+			console.log(
+				`✅ All comparisons passed (${passedTests}/${totalTests} user accounts)`
+			);
+		} catch (error) {
+			console.error('❌ Comparison failed:', error);
+		}
+	};
+
+	// Run initial comparison
+	compare();
+
+	// Run comparison every second to verify live updates
+	const interval = setInterval(compare, 1000);
+
+	const cleanup = async () => {
+		clearInterval(interval);
+		console.log('🧹 Cleaning up...');
+		await Promise.all([
+			...v1Subscribers.map((sub) => sub.unsubscribe()),
+			...v2Subscribers.map((sub) => sub.unsubscribe()),
+		]);
+		console.log('✅ Cleanup complete');
+		process.exit(0);
+	};
+
+	process.on('SIGINT', cleanup);
+	process.on('SIGTERM', cleanup);
+}
+
+testGrpcUserAccountSubscriberV1VsV2().catch(console.error);

package/scripts/postbuild.js

@@ -0,0 +1,95 @@
+// scripts/postbuild.js
+const fs = require('fs');
+const path = require('path');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+
+const forceEnv = yargs(hideBin(process.argv))
+	.option('force-env', {
+		type: 'string',
+		description: 'Specify environment to force (node or browser)',
+		choices: ['node', 'browser']
+	})
+	.argv?.forceEnv;
+
+const isomorphicPackages = ['grpc', 'anchor', 'anchor29'];
+const environments = ['node', 'browser'];
+
+environments.forEach((environment) => {
+	console.log(`Running ${environment} environment postbuild script`);
+	console.log(``);
+
+	isomorphicPackages.forEach((package) => {
+
+		// We want to overwrite the base isomorphic files (the "target" files) with the concrete implementation code and definition files (the "source" files).
+
+		const isomorphicFolderPath = path.join(
+			__dirname,
+			'..',
+			'lib',
+			environment,
+			'isomorphic'
+		);
+
+		const targetEnv = forceEnv ? forceEnv : environment;
+
+		const filesToSwap = [
+			{
+				source: `${package}.${targetEnv}.js`,
+				target: `${package}.js`,
+			},
+			{
+				source: `${package}.${targetEnv}.d.ts`,
+				target: `${package}.d.ts`,
+			},
+		];
+
+		for (const file of filesToSwap) {
+			const sourcePath = path.join(
+				isomorphicFolderPath,
+				file.source
+			);
+
+			const targetPath = path.join(
+				isomorphicFolderPath,
+				file.target
+			);
+
+			try {
+				const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+				fs.writeFileSync(targetPath, sourceContent);
+			} catch (error) {
+				console.error(
+					`Error processing isomophic package : ${package} :: ${error.message}`
+				);
+			}
+		}
+
+		// Delete other environment files for safety
+		environments.forEach((otherEnvironment) => {
+			if (otherEnvironment === targetEnv) {
+				return;
+			}
+
+			const otherTargetFiles = [
+				`${package}.${otherEnvironment}.js`,
+				`${package}.${otherEnvironment}.d.ts`,
+			];
+
+			for (const otherTargetFile of otherTargetFiles) {
+				const otherTargetPath = path.join(
+					__dirname,
+					'..',
+					'lib',
+					environment,
+					'isomorphic',
+					otherTargetFile
+				);
+
+				if (fs.existsSync(otherTargetPath)) {
+					fs.unlinkSync(otherTargetPath);
+				}
+			}
+		});
+	});
+});