@velocity-exchange/sdk 0.0.1

package/src/indicative-quotes/indicativeQuotesSender.ts

@@ -0,0 +1,233 @@
+import { Keypair } from '@solana/web3.js';
+import { BN } from '../isomorphic/anchor';
+import nacl from 'tweetnacl';
+import { decodeUTF8 } from 'tweetnacl-util';
+import WebSocket from 'ws';
+
+const SEND_INTERVAL = 500;
+const MAX_BUFFERED_AMOUNT = 20 * 1024; // 20 KB as worst case scenario
+
+type Quote = {
+	bidPrice: BN | null;
+	askPrice: BN | null;
+	bidBaseAssetAmount: BN | null;
+	askBaseAssetAmount: BN | null;
+	marketIndex: number;
+	isOracleOffset?: boolean;
+};
+
+type WsMessage = {
+	channel: string;
+	nonce?: string;
+	message?: string;
+};
+
+export class IndicativeQuotesSender {
+	private heartbeatTimeout: ReturnType<typeof setTimeout> | null = null;
+	private sendQuotesInterval: ReturnType<typeof setTimeout> | null = null;
+
+	private readonly heartbeatIntervalMs = 60000;
+	private reconnectDelay = 1000;
+	private ws: WebSocket | null = null;
+	private connected = false;
+
+	private quotes: Map<number, Quote[]> = new Map();
+
+	constructor(
+		private endpoint: string,
+		private keypair: Keypair
+	) {}
+
+	generateChallengeResponse(nonce: string): string {
+		const messageBytes = decodeUTF8(nonce);
+		const signature = nacl.sign.detached(messageBytes, this.keypair.secretKey);
+		const signatureBase64 = Buffer.from(signature).toString('base64');
+		return signatureBase64;
+	}
+
+	handleAuthMessage(message: WsMessage): void {
+		if (message['channel'] === 'auth' && message['nonce'] != null) {
+			const signatureBase64 = this.generateChallengeResponse(message['nonce']);
+			this.ws?.send(
+				JSON.stringify({
+					pubkey: this.keypair.publicKey.toBase58(),
+					signature: signatureBase64,
+				})
+			);
+		}
+
+		if (
+			message['channel'] === 'auth' &&
+			message['message']?.toLowerCase() === 'authenticated'
+		) {
+			this.connected = true;
+		}
+	}
+
+	async connect(): Promise<void> {
+		const ws = new WebSocket(
+			this.endpoint + '?pubkey=' + this.keypair.publicKey.toBase58()
+		);
+		this.ws = ws;
+		ws.on('open', async () => {
+			console.log('Connected to the server');
+			this.reconnectDelay = 1000;
+
+			ws.on('message', async (data: WebSocket.Data) => {
+				let message: WsMessage;
+				try {
+					message = JSON.parse(data.toString());
+				} catch (e) {
+					console.warn('Failed to parse json message: ', data.toString());
+					return;
+				}
+				this.startHeartbeatTimer();
+
+				if (message['channel'] === 'auth') {
+					this.handleAuthMessage(message);
+				}
+
+				if (
+					message['channel'] === 'auth' &&
+					message['message']?.toLowerCase() === 'authenticated'
+				) {
+					this.sendQuotesInterval = setInterval(() => {
+						if (this.connected) {
+							for (const [marketIndex, quotes] of this.quotes.entries()) {
+								const message = {
+									market_index: marketIndex,
+									market_type: 'perp',
+									quotes: quotes.map((quote) => {
+										return {
+											bid_price: quote.bidPrice
+												? quote.bidPrice.toString()
+												: null,
+											ask_price: quote.askPrice
+												? quote.askPrice.toString()
+												: null,
+											bid_size: quote.bidBaseAssetAmount
+												? quote.bidBaseAssetAmount.toString()
+												: null,
+											ask_size: quote.askBaseAssetAmount
+												? quote.askBaseAssetAmount.toString()
+												: null,
+											is_oracle_offset: quote.isOracleOffset,
+										};
+									}),
+								};
+								try {
+									if (
+										this.ws?.readyState === WebSocket.OPEN &&
+										this.ws?.bufferedAmount < MAX_BUFFERED_AMOUNT
+									) {
+										this.ws.send(JSON.stringify(message));
+									}
+								} catch (err) {
+									console.error('Error sending quote:', err);
+								}
+							}
+						}
+					}, SEND_INTERVAL);
+				}
+			});
+
+			ws.on('close', () => {
+				console.log('Disconnected from the server');
+				this.reconnect();
+			});
+
+			ws.on('error', (error: Error) => {
+				console.error('WebSocket error:', error);
+				this.reconnect();
+			});
+		});
+
+		ws.on('unexpected-response', async (request, response) => {
+			console.error(
+				'Unexpected response, reconnecting in 5s:',
+				response?.statusCode
+			);
+			setTimeout(() => {
+				if (this.heartbeatTimeout) clearTimeout(this.heartbeatTimeout);
+				if (this.sendQuotesInterval) clearInterval(this.sendQuotesInterval);
+				this.reconnect();
+			}, 5000);
+		});
+
+		ws.on('error', async (error: Error) => {
+			console.error('WS closed from error, reconnecting in 1s:', error);
+			setTimeout(() => {
+				if (this.heartbeatTimeout) clearTimeout(this.heartbeatTimeout);
+				if (this.sendQuotesInterval) clearInterval(this.sendQuotesInterval);
+				this.reconnect();
+			}, 1000);
+		});
+	}
+
+	private startHeartbeatTimer() {
+		if (this.heartbeatTimeout) {
+			clearTimeout(this.heartbeatTimeout);
+		}
+		this.heartbeatTimeout = setTimeout(() => {
+			console.warn('No heartbeat received within 30 seconds, reconnecting...');
+			this.reconnect();
+		}, this.heartbeatIntervalMs);
+	}
+
+	setQuote(newQuotes: Quote | Quote[]): void {
+		if (!this.connected) {
+			console.warn('Setting quote before connected to the server, ignoring');
+		}
+		const quotes = Array.isArray(newQuotes) ? newQuotes : [newQuotes];
+		const newQuoteMap = new Map<number, Quote[]>();
+		for (const quote of quotes) {
+			if (
+				quote.marketIndex == null ||
+				quote.bidPrice == null ||
+				quote.askPrice == null ||
+				quote.bidBaseAssetAmount == null ||
+				quote.askBaseAssetAmount == null
+			) {
+				console.warn(
+					'Received incomplete quote, ignoring and deleting old quote',
+					quote
+				);
+				if (quote.marketIndex != null) {
+					this.quotes.delete(quote.marketIndex);
+				}
+				return;
+			}
+			if (!newQuoteMap.has(quote.marketIndex)) {
+				newQuoteMap.set(quote.marketIndex, []);
+			}
+			newQuoteMap.get(quote.marketIndex)?.push(quote);
+		}
+		newQuoteMap.forEach((quotes, marketIndex) => {
+			this.quotes.set(marketIndex, quotes);
+		});
+	}
+
+	private reconnect() {
+		if (this.ws) {
+			this.ws.removeAllListeners();
+			this.ws.terminate();
+		}
+
+		if (this.heartbeatTimeout) {
+			clearTimeout(this.heartbeatTimeout);
+			this.heartbeatTimeout = null;
+		}
+		if (this.sendQuotesInterval) {
+			clearInterval(this.sendQuotesInterval);
+			this.sendQuotesInterval = null;
+		}
+
+		console.log(
+			`Reconnecting to WebSocket in ${this.reconnectDelay / 1000} seconds...`
+		);
+		setTimeout(() => {
+			this.connect();
+			this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30000);
+		}, this.reconnectDelay);
+	}
+}

package/src/isomorphic/README.md

@@ -0,0 +1,19 @@
+# Isomorphic Code Explanation
+
+Soem of the features you might want to add to the SDK may only be compatible with particular execution environments (usually a non-browser one). To get that working without breaking the SDK for people in other environments, you need to get your code working in an isomorphic way.
+
+This README will try explain how to do this, and you should be able to follow the example of other pieces of isomorphic code in this folder.
+
+## High Level Explanation
+
+At a high level, we just want to make sure that we're not importing any incompatible code into the final compiled .js output files. The only real way this can "get done" is by importing types or by importing classes/methods/values out of an offending packages. The goal of our isomorphic seperation is to ensure that we have SDK-Side code which is still properly typed and easy for devs to work with, without putting anything bad into the output code. We will do this with some typescript magic and a simple but handy postbuild script.
+
+## Step-by-step isomorphic code:
+
+1. Create [your-package-name].d.ts, [your-package-name].browser.ts, and [your-package-name].node.ts files.
+2. Remove any imports of an offending library which aren't going through our dedicated isomorphic files. Instead import the TYPES of these and place them in the `.d.ts` file (definition file). Note to import ONLY THE TYPES you use `import type {stuff}` instead of just `import {stuff}`.
+3. The definition file should be exporting types only, and the files that were previously importing things directly from the library should be able to import from the definition file now instead. You might see some typescript issues when you import things from this definition file because typescript thinks it's "just a type" -- you can safely @ts-ignore these errors, but the types SHOULD at least be correct when you are using them.
+4. For concrete classes, methods, constants, etc. that you need to make available - you will place them in the `.browser` and `.node` files. You should be able to pretty flexibly export them however you want, just make sure the definition file has a matching type for how you're doing it. See `grpc.d.ts` and `grpc.node.ts` to look at how we're doing this for `createClient`. For the "bad" isomorphic file it's probably best to throw an error so that the consumer knows they shouldn't be using this particular feature.
+5. Note about enums :: they're weird and annoying. If you follow how the enum type `CommitmentLevel` was exported for the grpc package though you should be fine.
+6. Add the name of your package to `postbuild.js`.
+7. when you run `build` it will build the node version of all of these packages. You can run `build:browser` to build the browser side ones instead.

package/src/isomorphic/anchor.browser.ts

@@ -0,0 +1,44 @@
+// eslint-disable-next-line no-restricted-imports -- browser stub: minimal BN without pulling full Anchor
+import BNJS from 'bn.js';
+import * as web3 from '@solana/web3.js';
+
+export class BN extends BNJS {}
+
+export {
+	BorshAccountsCoder,
+	BorshEventCoder,
+	BorshInstructionCoder,
+	BorshCoder,
+} from '@anchor-lang/core';
+
+export const utils = {
+	bytes: {
+		utf8: {
+			encode: (s: string) => new TextEncoder().encode(s),
+		},
+	},
+};
+
+export { web3 };
+
+export class AnchorProvider {
+	constructor() {
+		throw new Error(
+			'AnchorProvider is not supported in the browser build. Use `VelocityCore` (pure builders/decoders/PDAs) instead of `VelocityClient`.'
+		);
+	}
+}
+
+export class Program<_T = any> {
+	constructor() {
+		throw new Error(
+			'Program is not supported in the browser build. Use `VelocityCore` (pure builders/decoders/PDAs) instead of `VelocityClient`.'
+		);
+	}
+}
+
+export type Idl = any;
+export type Coder = any;
+export type ProgramAccount = any;
+export type Event = any;
+export type Wallet = any;

package/src/isomorphic/anchor.node.ts

@@ -0,0 +1 @@
+export * from '@coral-xyz/anchor';

package/src/isomorphic/anchor.ts

@@ -0,0 +1 @@
+export * from '@coral-xyz/anchor';

package/src/isomorphic/anchor29.browser.ts

@@ -0,0 +1,24 @@
+// eslint-disable-next-line no-restricted-imports -- browser stub: minimal BN without pulling full Anchor
+import BNJS from 'bn.js';
+import * as web3 from '@solana/web3.js';
+
+export class BN extends BNJS {}
+export { web3 };
+
+export class AnchorProvider {
+	constructor() {
+		throw new Error(
+			'Anchor (0.29) is not supported in the browser build. Use `VelocityCore` instead of `VelocityClient`.'
+		);
+	}
+}
+
+export class Program<_T = any> {
+	constructor() {
+		throw new Error(
+			'Anchor (0.29) Program is not supported in the browser build. Use `VelocityCore` instead of `VelocityClient`.'
+		);
+	}
+}
+
+export type IdlAccounts<_T = any> = any;

package/src/isomorphic/anchor29.node.ts

@@ -0,0 +1 @@
+export * from '@coral-xyz/anchor-29';

package/src/isomorphic/anchor29.ts

@@ -0,0 +1 @@
+export * from '@coral-xyz/anchor-29';

package/src/isomorphic/grpc.browser.ts

@@ -0,0 +1,4 @@
+// Export a function to create a new Client instance
+export function createClient(..._args: any) {
+	throw new Error('Only available in node context');
+}

package/src/isomorphic/grpc.node.ts

@@ -0,0 +1,130 @@
+import type Client from '@triton-one/yellowstone-grpc';
+import type {
+	SubscribeRequest,
+	SubscribeUpdate,
+} from '@triton-one/yellowstone-grpc';
+import {
+	CommitmentLevel,
+	ClientDuplexStream,
+	ChannelOptions,
+} from '@triton-one/yellowstone-grpc';
+
+// Re-export types for helius-laserstream (these are type-only imports so they don't cause runtime errors)
+export type {
+	LaserstreamConfig,
+	SubscribeRequest as LaserSubscribeRequest,
+	SubscribeUpdate as LaserSubscribeUpdate,
+} from 'helius-laserstream';
+
+// Lazy-loaded module reference for helius-laserstream
+let laserStreamModule: typeof import('helius-laserstream') | null = null;
+let laserStreamLoadError: Error | null = null;
+
+// Try to load helius-laserstream (it's an optional dependency that may not be available on all platforms)
+async function loadLaserStream(): Promise<typeof import('helius-laserstream')> {
+	if (laserStreamModule) {
+		return laserStreamModule;
+	}
+	if (laserStreamLoadError) {
+		throw laserStreamLoadError;
+	}
+	try {
+		laserStreamModule = await import('helius-laserstream');
+		return laserStreamModule;
+	} catch (err) {
+		laserStreamLoadError = new Error(
+			`helius-laserstream is not available on this platform. ` +
+				`LaserStream functionality requires Linux or macOS. ` +
+				`Original error: ${err instanceof Error ? err.message : String(err)}`
+		);
+		throw laserStreamLoadError;
+	}
+}
+
+// Lazy getters for LaserStream exports - these throw helpful errors if the module isn't available
+export const LaserCommitmentLevel = new Proxy(
+	{} as typeof import('helius-laserstream').CommitmentLevel,
+	{
+		get(_target, prop) {
+			// Return placeholder values for type checking - actual usage should go through getLaserCommitmentLevel()
+			const values: Record<string, number> = {
+				PROCESSED: 0,
+				CONFIRMED: 1,
+				FINALIZED: 2,
+			};
+			return values[prop as string];
+		},
+	}
+);
+
+export const CompressionAlgorithms = new Proxy(
+	{} as typeof import('helius-laserstream').CompressionAlgorithms,
+	{
+		get(_target, prop) {
+			const values: Record<string, number> = {
+				identity: 0,
+				deflate: 1,
+				gzip: 2,
+				zstd: 3,
+			};
+			return values[prop as string];
+		},
+	}
+);
+
+// Async function to get the actual LaserSubscribe function
+export async function getLaserSubscribe(): Promise<
+	typeof import('helius-laserstream').subscribe
+> {
+	const module = await loadLaserStream();
+	return module.subscribe;
+}
+
+// Async function to get actual LaserCommitmentLevel
+export async function getLaserCommitmentLevel(): Promise<
+	typeof import('helius-laserstream').CommitmentLevel
+> {
+	const module = await loadLaserStream();
+	return module.CommitmentLevel;
+}
+
+// Async function to get actual CompressionAlgorithms
+export async function getLaserCompressionAlgorithms(): Promise<
+	typeof import('helius-laserstream').CompressionAlgorithms
+> {
+	const module = await loadLaserStream();
+	return module.CompressionAlgorithms;
+}
+
+let laserSubscribeWarned = false;
+
+// Backwards-compatible wrapper that lazy-loads the module and warns once.
+export function LaserSubscribe(
+	...args: Parameters<typeof import('helius-laserstream').subscribe>
+): ReturnType<typeof import('helius-laserstream').subscribe> {
+	if (!laserSubscribeWarned) {
+		laserSubscribeWarned = true;
+		console.warn(
+			'LaserSubscribe is deprecated. Use getLaserSubscribe() for optional helius-laserstream support.'
+		);
+	}
+	return getLaserSubscribe().then((subscribe) => subscribe(...args));
+}
+
+export { CommitmentLevel, Client };
+export type {
+	ClientDuplexStream,
+	ChannelOptions,
+	SubscribeRequest,
+	SubscribeUpdate,
+};
+
+// Export a function to create a new Client instance
+export async function createClient(
+	...args: ConstructorParameters<typeof Client>
+): Promise<Client> {
+	const { default: Client_ } = await import('@triton-one/yellowstone-grpc');
+	const client = new Client_(...args);
+	await client.connect();
+	return client;
+}

package/src/isomorphic/grpc.ts

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