@velocity-exchange/sdk 0.0.1

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

@@ -0,0 +1,284 @@
+import { VelocityClient } from '../src/velocityClient';
+import { grpcVelocityClientAccountSubscriberV2 } from '../src/accounts/grpcVelocityClientAccountSubscriberV2';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { VelocityClientConfig } from '../src/velocityClientConfig';
+import {
+	VELOCITY_PROGRAM_ID,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	Wallet,
+	OracleInfo,
+	decodeName,
+} 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 { grpcMultiUserAccountSubscriber } from '../src/accounts/grpcMultiUserAccountSubscriber';
+
+const GRPC_ENDPOINT = process.env.GRPC_ENDPOINT;
+const TOKEN = process.env.TOKEN;
+const RPC_ENDPOINT = process.env.RPC_ENDPOINT;
+
+async function initializeSingleGrpcClient() {
+	console.log('🚀 Initializing single gRPC Drift Client...');
+
+	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);
+
+	// Get perp market accounts
+	const allPerpMarketProgramAccounts =
+		(await program.account.perpMarket.all()) as ProgramAccount<PerpMarketAccount>[];
+	const perpMarketProgramAccounts = allPerpMarketProgramAccounts.filter((val) =>
+		[46].includes(val.account.marketIndex)
+	);
+	const perpMarketIndexes = perpMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
+	);
+
+	// Get spot market accounts
+	const allSpotMarketProgramAccounts =
+		(await program.account.spotMarket.all()) as ProgramAccount<SpotMarketAccount>[];
+	const spotMarketProgramAccounts = allSpotMarketProgramAccounts.filter((val) =>
+		[0].includes(val.account.marketIndex)
+	);
+	const spotMarketIndexes = spotMarketProgramAccounts.map(
+		(val) => val.account.marketIndex
+	);
+
+	// Get oracle infos
+	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,
+			});
+		}
+	}
+
+	console.log(
+		`📊 Markets: ${perpMarketIndexes.length} perp, ${spotMarketIndexes.length} spot`
+	);
+	console.log(`🔮 Oracles: ${oracleInfos.length}`);
+
+	const grpcConfigs = {
+		endpoint: GRPC_ENDPOINT,
+		token: TOKEN,
+		commitmentLevel: CommitmentLevel.PROCESSED,
+		channelOptions: {
+			grpcKeepAliveTimeout: 1_000,
+			grpcTcpKeepalive: 10_000,
+		},
+	};
+
+	const multiUserSubsciber = new grpcMultiUserAccountSubscriber(
+		program,
+		grpcConfigs
+	);
+
+	const baseAccountSubscription = {
+		type: 'grpc' as const,
+		grpcConfigs,
+		grpcMultiUserAccountSubscriber: multiUserSubsciber,
+	};
+
+	const config: VelocityClientConfig = {
+		connection,
+		wallet,
+		programID: new PublicKey(VELOCITY_PROGRAM_ID),
+		accountSubscription: {
+			...baseAccountSubscription,
+			velocityClientAccountSubscriber: grpcVelocityClientAccountSubscriberV2,
+		},
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
+	};
+
+	const client = new VelocityClient(config);
+
+	// Set up event listeners
+	const eventCounts = {
+		stateAccountUpdate: 0,
+		perpMarketAccountUpdate: 0,
+		spotMarketAccountUpdate: 0,
+		oraclePriceUpdate: 0,
+		update: 0,
+	};
+
+	console.log('🎧 Setting up event listeners...');
+
+	client.eventEmitter.on('stateAccountUpdate', (_data) => {
+		eventCounts.stateAccountUpdate++;
+	});
+
+	client.eventEmitter.on('perpMarketAccountUpdate', (_data) => {
+		eventCounts.perpMarketAccountUpdate++;
+	});
+
+	client.eventEmitter.on('spotMarketAccountUpdate', (_data) => {
+		eventCounts.spotMarketAccountUpdate++;
+	});
+
+	client.eventEmitter.on('oraclePriceUpdate', (_publicKey, _source, _data) => {
+		eventCounts.oraclePriceUpdate++;
+	});
+
+	client.accountSubscriber.eventEmitter.on('update', () => {
+		eventCounts.update++;
+	});
+
+	// Subscribe
+	console.log('🔗 Subscribing to accounts...');
+	await client.subscribe();
+
+	console.log('✅ Client subscribed successfully!');
+	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 () => {
+		try {
+			// Test getPerpMarketAccount for each perp market (50 times per second per market)
+			for (const marketIndex of perpMarketIndexes) {
+				const perpMarketAccount = client.getPerpMarketAccount(marketIndex);
+				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(),
+						})
+					);
+				} 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);
+		}
+	}, 20); // 50 times per second = 1000ms / 50 = 20ms interval
+
+	// Log periodic stats
+	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)`
+		);
+	}, 5000);
+
+	// Handle shutdown signals - just exit without cleanup since they never unsubscribe
+	process.on('SIGINT', () => {
+		console.log('\n🛑 Shutting down...');
+		clearInterval(loadTestInterval);
+		clearInterval(statsInterval);
+		process.exit(0);
+	});
+
+	process.on('SIGTERM', () => {
+		console.log('\n🛑 Shutting down...');
+		clearInterval(loadTestInterval);
+		clearInterval(statsInterval);
+		process.exit(0);
+	});
+
+	return client;
+}
+
+initializeSingleGrpcClient().catch(console.error);

package/scripts/updateVersion.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const packageJson = require('../package.json');
+
+const versionFilePath = path.join(__dirname, '..', 'VERSION');
+
+let version = fs.readFileSync(versionFilePath, 'utf8');
+version = version.replace(/\n/g, '');
+
+const filesToReplace = [
+    // sdk/src/idl/drift.json
+    path.join(__dirname, '..', 'src', 'idl', 'drift.json'),
+    // programs/drift/Cargo.toml
+    path.join(__dirname, '..', '..', 'programs', 'drift', 'Cargo.toml'),
+    // Cargo.lock
+    path.join(__dirname, '..', '..', 'Cargo.lock'),
+]
+
+console.log(`Updating versions from ${version} to ${packageJson.version} in:`);
+for (const file of filesToReplace) {
+    console.log(`* ${file}`);
+    const fileContents = fs.readFileSync(file, 'utf8');
+    const newFileContents = fileContents.replace(version, packageJson.version);
+    fs.writeFileSync(file, newFileContents);
+}
+
+fs.writeFileSync(versionFilePath, packageJson.version);
+console.log("");

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 {
+	VELOCITY_PROGRAM_ID,
+	PerpMarketAccount,
+	SpotMarketAccount,
+	OracleInfo,
+	Wallet,
+	ZERO,
+} from '../src';
+import { VelocityClient } from '../src/velocityClient';
+import { VelocityClientConfig } from '../src/velocityClientConfig';
+
+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(VELOCITY_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 VelocityClient with websocket subscription (lightweight)
+	const clientConfig: VelocityClientConfig = {
+		connection,
+		wallet,
+		programID: programId,
+		accountSubscription: {
+			type: 'websocket',
+			commitment: 'processed',
+		},
+		perpMarketIndexes,
+		spotMarketIndexes,
+		oracleInfos,
+		env: 'devnet',
+	};
+	const client = new VelocityClient(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/accounts/README_WebSocketAccountSubscriberV2.md

@@ -0,0 +1,95 @@
+# WebSocketAccountSubscriberV2
+
+This is a new implementation of the WebSocket account subscriber that utilizes the [gill](https://www.npmjs.com/package/gill) library for improved RPC and WebSocket functionality.
+
+## Overview
+
+The `WebSocketAccountSubscriberV2` class provides the same interface as the original `WebSocketAccountSubscriber` but uses gill's modern TypeScript client library for Solana blockchain interactions.
+
+## Usage
+
+The usage is identical to the original `WebSocketAccountSubscriber`:
+
+```typescript
+import { WebSocketAccountSubscriberV2 } from './accounts/webSocketAccountSubscriberV2';
+
+const subscriber = new WebSocketAccountSubscriberV2(
+	'userAccount', // account name
+	program, // Anchor program instance
+	userAccountPublicKey, // PublicKey of the account to subscribe to
+	decodeBuffer, // optional custom decode function
+	resubOpts, // optional resubscription options
+	commitment // optional commitment level
+);
+
+// Subscribe to account changes
+await subscriber.subscribe((data) => {
+	console.log('Account updated:', data);
+});
+
+// Unsubscribe when done
+await subscriber.unsubscribe();
+```
+
+### Polling Instead of Resubscribing
+
+For accounts that rarely update (like long-tail markets), you can use polling instead of resubscribing to reduce resource usage:
+
+```typescript
+const resubOpts = {
+	resubTimeoutMs: 30000, // 30 seconds
+	logResubMessages: true,
+	usePollingInsteadOfResub: true, // Enable polling mode
+	pollingIntervalMs: 30000, // Poll every 30 seconds (optional, defaults to 30000)
+};
+
+const subscriber = new WebSocketAccountSubscriberV2(
+	'perpMarket', // account name
+	program,
+	marketPublicKey,
+	undefined, // decodeBuffer
+	resubOpts
+);
+```
+
+**How it works:**
+1. Initially subscribes to WebSocket updates
+2. If no WebSocket data is received for `resubTimeoutMs` (30s), switches to websocket+polling mode if `usePollingInsteadOfResub` is specified true, else just resubscribes(unsub, sub).
+3. Polls every `pollingIntervalMs` (alongside websocket connection) to check for updates by:
+   - Storing current account buffer state
+   - Fetching latest account data
+   - Comparing buffers to detect any missed updates
+4. If polling detects new data (indicating missed WebSocket events):
+   - Immediately stops polling
+   - Resubscribes to WebSocket to restore real-time updates
+   - This helps recover from degraded WebSocket connections
+5. If a WebSocket event is received while polling:
+   - Polling is automatically stopped
+   - System continues with normal WebSocket updates
+6. This approach provides:
+   - Efficient handling of rarely-updated accounts
+   - Automatic recovery from WebSocket connection issues
+   - Seamless fallback between polling and WebSocket modes
+
+## Implementation Details
+
+### Gill Integration
+
+The implementation uses gill's `createSolanaClient` function to create RPC and WebSocket clients:
+
+```typescript
+import { createSolanaClient } from 'gill';
+
+const { rpc, rpcSubscriptions } = createSolanaClient({
+	urlOrMoniker: rpcUrl, // or "mainnet", "devnet", etc.
+});
+```
+
+### Key Differences from Original
+
+1. **RPC Client**: Uses gill's `rpc` client for account fetching
+2. **WebSocket Subscriptions**: Uses gill's `rpcSubscriptions` for real-time updates
+3. **Address Handling**: Converts `PublicKey` to gill's `Address` type for compatibility
+4. **Response Formatting**: Converts gill responses to match the expected `AccountInfo<Buffer>` format
+5. **Abort Signal**: Utilizes AbortSignal nodejs/web class to shutdown websocket connection synchronously
+6. **Polling Mode**: Optional polling mechanism for accounts that rarely update