@velocity-exchange/sdk 0.0.1

package/src/pyth/utils.ts

@@ -0,0 +1,13 @@
+import { PublicKey } from '@solana/web3.js';
+
+export const getGuardianSetPda = (
+	guardianSetIndex: number,
+	wormholeProgramId: PublicKey
+) => {
+	const guardianSetIndexBuf = Buffer.alloc(4);
+	guardianSetIndexBuf.writeUInt32BE(guardianSetIndex, 0);
+	return PublicKey.findProgramAddressSync(
+		[Buffer.from('GuardianSet'), guardianSetIndexBuf],
+		wormholeProgramId
+	)[0];
+};

package/src/slot/SlotSubscriber.ts

@@ -0,0 +1,108 @@
+import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type SlotSubscriberConfig = {
+	resubTimeoutMs?: number;
+}; // for future customization
+
+export interface SlotSubscriberEvents {
+	newSlot: (newSlot: number) => void;
+}
+
+export class SlotSubscriber {
+	currentSlot: number;
+	subscriptionId: number;
+	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
+
+	// Reconnection
+	timeoutId?: ReturnType<typeof setTimeout>;
+	resubTimeoutMs?: number;
+	isUnsubscribing = false;
+	receivingData = false;
+
+	public constructor(
+		private connection: Connection,
+		config?: SlotSubscriberConfig
+	) {
+		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = config?.resubTimeoutMs;
+		if (this.resubTimeoutMs < 1000) {
+			console.log(
+				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
+			);
+		}
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscriptionId != null) {
+			return;
+		}
+
+		const newSlot = await this.connection.getSlot('confirmed');
+		this.updateCurrentSlot(newSlot);
+
+		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+			const newSlot = slotInfo.slot;
+
+			if (!this.currentSlot || this.currentSlot < newSlot) {
+				if (this.resubTimeoutMs && !this.isUnsubscribing) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+				}
+				this.updateCurrentSlot(newSlot);
+			}
+		});
+
+		if (this.resubTimeoutMs) {
+			this.receivingData = true;
+			this.setTimeout();
+		}
+	}
+
+	private updateCurrentSlot(slot: number) {
+		this.currentSlot = slot;
+		this.eventEmitter.emit('newSlot', slot);
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(
+					`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`
+				);
+				await this.unsubscribe(true);
+				this.receivingData = false;
+				await this.subscribe();
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	public getSlot(): number {
+		return this.currentSlot;
+	}
+
+	public async unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		if (this.subscriptionId != null) {
+			await this.connection.removeSlotChangeListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+			this.isUnsubscribing = false;
+		} else {
+			this.isUnsubscribing = false;
+		}
+	}
+}

package/src/slot/SlothashSubscriber.ts

@@ -0,0 +1,126 @@
+import {
+	Commitment,
+	Connection,
+	SYSVAR_SLOT_HASHES_PUBKEY,
+} from '@solana/web3.js';
+import bs58 from 'bs58';
+import { BN } from '../isomorphic/anchor';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type SlothashSubscriberConfig = {
+	resubTimeoutMs?: number;
+	commitment?: Commitment;
+}; // for future customization
+
+export type Slothash = {
+	slot: number;
+	hash: string;
+};
+
+export class SlothashSubscriber {
+	currentSlothash: Slothash;
+	subscriptionId: number;
+	commitment: Commitment;
+
+	// Reconnection
+	timeoutId?: ReturnType<typeof setTimeout>;
+	resubTimeoutMs?: number;
+	isUnsubscribing = false;
+	receivingData = false;
+
+	public constructor(
+		private connection: Connection,
+		config?: SlothashSubscriberConfig
+	) {
+		this.resubTimeoutMs = config?.resubTimeoutMs;
+		this.commitment = config?.commitment ?? 'processed';
+		if (this.resubTimeoutMs < 1000) {
+			console.log(
+				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
+			);
+		}
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscriptionId != null) {
+			return;
+		}
+
+		const currentAccountData = await this.connection.getAccountInfo(
+			SYSVAR_SLOT_HASHES_PUBKEY,
+			this.commitment
+		);
+		if (currentAccountData == null) {
+			throw new Error('Failed to retrieve current slot hash');
+		}
+		this.currentSlothash = deserializeSlothash(currentAccountData.data);
+
+		this.subscriptionId = this.connection.onAccountChange(
+			SYSVAR_SLOT_HASHES_PUBKEY,
+			(slothashInfo, context) => {
+				if (!this.currentSlothash || this.currentSlothash.slot < context.slot) {
+					if (this.resubTimeoutMs && !this.isUnsubscribing) {
+						this.receivingData = true;
+						clearTimeout(this.timeoutId);
+						this.setTimeout();
+					}
+					this.currentSlothash = deserializeSlothash(slothashInfo.data);
+				}
+			},
+			this.commitment
+		);
+
+		if (this.resubTimeoutMs) {
+			this.receivingData = true;
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(
+					`No new slot in ${this.resubTimeoutMs}ms, slot subscriber resubscribing`
+				);
+				await this.unsubscribe(true);
+				this.receivingData = false;
+				await this.subscribe();
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	public getSlothash(): Slothash {
+		return this.currentSlothash;
+	}
+
+	public async unsubscribe(onResub = false): Promise<void> {
+		if (!onResub) {
+			this.resubTimeoutMs = undefined;
+		}
+		this.isUnsubscribing = true;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
+		if (this.subscriptionId != null) {
+			await this.connection.removeSlotChangeListener(this.subscriptionId);
+			this.subscriptionId = undefined;
+			this.isUnsubscribing = false;
+		} else {
+			this.isUnsubscribing = false;
+		}
+	}
+}
+
+function deserializeSlothash(data: Buffer): Slothash {
+	const slotNumber = new BN(data.subarray(8, 16), 10, 'le');
+	const hash = bs58.encode(data.subarray(16, 48));
+	return {
+		slot: slotNumber.toNumber(),
+		hash,
+	};
+}

package/src/swap/UnifiedSwapClient.ts

@@ -0,0 +1,315 @@
+import {
+	Connection,
+	PublicKey,
+	TransactionMessage,
+	AddressLookupTableAccount,
+	VersionedTransaction,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import { BN } from '../isomorphic/anchor';
+import {
+	JupiterClient,
+	QuoteResponse as JupiterQuoteResponse,
+} from '../jupiter/jupiterClient';
+import { TitanClient, SwapMode as TitanSwapMode } from '../titan/titanClient';
+
+export type SwapMode = 'ExactIn' | 'ExactOut';
+export type SwapClientType = 'jupiter' | 'titan';
+
+/**
+ * Unified quote response interface that combines properties from both Jupiter and Titan
+ * This provides a consistent interface while allowing for provider-specific fields
+ */
+export interface UnifiedQuoteResponse {
+	// Core properties available in both providers
+	inputMint: string;
+	inAmount: string;
+	outputMint: string;
+	outAmount: string;
+	swapMode: SwapMode;
+	slippageBps: number;
+	routePlan: Array<{ swapInfo: any; percent: number }>;
+
+	// Optional properties that may not be available in all providers
+	otherAmountThreshold?: string; // Jupiter has this, Titan doesn't
+	priceImpactPct?: string; // Jupiter provides this, Titan doesn't (we calculate it)
+	platformFee?: { amount?: string; feeBps?: number }; // Format varies between providers
+	contextSlot?: number;
+	timeTaken?: number;
+	error?: string;
+	errorCode?: string;
+}
+
+export interface SwapQuoteParams {
+	inputMint: PublicKey;
+	outputMint: PublicKey;
+	amount: BN;
+	userPublicKey?: PublicKey; // Required for Titan, optional for Jupiter
+	maxAccounts?: number;
+	slippageBps?: number;
+	swapMode?: SwapMode;
+	onlyDirectRoutes?: boolean;
+	excludeDexes?: string[];
+	sizeConstraint?: number; // Titan-specific
+	accountsLimitWritable?: number; // Titan-specific
+	autoSlippage?: boolean; // Jupiter-specific
+	maxAutoSlippageBps?: number; // Jupiter-specific
+	usdEstimate?: number; // Jupiter-specific
+}
+
+export interface SwapTransactionParams {
+	quote: UnifiedQuoteResponse;
+	userPublicKey: PublicKey;
+	slippageBps?: number;
+}
+
+export interface SwapTransactionResult {
+	transaction?: VersionedTransaction; // Jupiter returns this
+	transactionMessage?: TransactionMessage; // Titan returns this
+	lookupTables?: AddressLookupTableAccount[]; // Titan returns this
+}
+
+export class UnifiedSwapClient {
+	private client: JupiterClient | TitanClient;
+	private clientType: SwapClientType;
+
+	/**
+	 * Create a unified swap client
+	 * @param clientType - 'jupiter' or 'titan'
+	 * @param connection - Solana connection
+	 * @param authToken - For Titan: auth token (required when not using proxy). For Jupiter: API key (required for api.jup.ag, get free key at https://portal.jup.ag)
+	 * @param url - Optional custom URL
+	 * @param proxyUrl - Optional proxy URL for Titan
+	 */
+	constructor({
+		clientType,
+		connection,
+		authToken,
+		url,
+		proxyUrl,
+	}: {
+		clientType: SwapClientType;
+		connection: Connection;
+		authToken?: string; // For Titan: auth token. For Jupiter: API key (required for api.jup.ag)
+		url?: string; // Optional custom URL
+		proxyUrl?: string; // Optional proxy URL for Titan
+	}) {
+		this.clientType = clientType;
+
+		if (clientType === 'jupiter') {
+			this.client = new JupiterClient({
+				connection,
+				url,
+				apiKey: authToken,
+			});
+		} else if (clientType === 'titan') {
+			this.client = new TitanClient({
+				connection,
+				authToken: authToken || '', // Not needed when using proxy
+				url,
+				proxyUrl,
+			});
+		} else {
+			throw new Error(`Unsupported client type: ${clientType}`);
+		}
+	}
+
+	/**
+	 * Get a swap quote from the underlying client
+	 */
+	public async getQuote(
+		params: SwapQuoteParams
+	): Promise<UnifiedQuoteResponse> {
+		if (this.clientType === 'jupiter') {
+			const jupiterClient = this.client as JupiterClient;
+			const {
+				userPublicKey: _userPublicKey, // Not needed for Jupiter
+				sizeConstraint: _sizeConstraint, // Jupiter-specific params to exclude
+				accountsLimitWritable: _accountsLimitWritable,
+				...jupiterParams
+			} = params;
+
+			return await jupiterClient.getQuote(jupiterParams);
+		} else {
+			const titanClient = this.client as TitanClient;
+			const {
+				autoSlippage: _autoSlippage, // Titan-specific params to exclude
+				maxAutoSlippageBps: _maxAutoSlippageBps,
+				usdEstimate: _usdEstimate,
+				...titanParams
+			} = params;
+
+			if (!titanParams.userPublicKey) {
+				throw new Error('userPublicKey is required for Titan quotes');
+			}
+
+			// Cast to ensure TypeScript knows userPublicKey is defined
+			const titanParamsWithUser = {
+				...titanParams,
+				userPublicKey: titanParams.userPublicKey,
+				swapMode: titanParams.swapMode as string, // Titan expects string
+				sizeConstraint: titanParams.sizeConstraint || 1280 - 375, // Use same default as getSwapInstructions
+			};
+
+			return await titanClient.getQuote(titanParamsWithUser);
+		}
+	}
+
+	/**
+	 * Get a swap transaction from the underlying client
+	 */
+	public async getSwap(
+		params: SwapTransactionParams
+	): Promise<SwapTransactionResult> {
+		if (this.clientType === 'jupiter') {
+			const jupiterClient = this.client as JupiterClient;
+			// Cast the quote to Jupiter's specific QuoteResponse type
+			const jupiterParams = {
+				...params,
+				quote: params.quote as JupiterQuoteResponse,
+			};
+			const transaction = await jupiterClient.getSwap(jupiterParams);
+			return { transaction };
+		} else {
+			const titanClient = this.client as TitanClient;
+			const { userPublicKey } = params;
+
+			// For Titan, we need to reconstruct the parameters from the quote
+			const result = await titanClient.getSwap({
+				userPublicKey,
+			});
+
+			return {
+				transactionMessage: result.transactionMessage,
+				lookupTables: result.lookupTables,
+			};
+		}
+	}
+
+	/**
+	 * Get swap instructions from the underlying client (Jupiter or Titan)
+	 * This is the core swap logic without any context preparation
+	 */
+	public async getSwapInstructions({
+		inputMint,
+		outputMint,
+		amount,
+		userPublicKey,
+		slippageBps,
+		swapMode = 'ExactIn',
+		onlyDirectRoutes = false,
+		quote,
+		sizeConstraint,
+	}: {
+		inputMint: PublicKey;
+		outputMint: PublicKey;
+		amount: BN;
+		userPublicKey: PublicKey;
+		slippageBps?: number;
+		swapMode?: SwapMode;
+		onlyDirectRoutes?: boolean;
+		quote?: UnifiedQuoteResponse;
+		sizeConstraint?: number;
+	}): Promise<{
+		instructions: TransactionInstruction[];
+		lookupTables: AddressLookupTableAccount[];
+	}> {
+		const isExactOut = swapMode === 'ExactOut';
+		let swapInstructions: TransactionInstruction[];
+		let lookupTables: AddressLookupTableAccount[];
+
+		if (this.clientType === 'jupiter') {
+			const jupiterClient = this.client as JupiterClient;
+
+			// Get quote if not provided
+			let finalQuote = quote as JupiterQuoteResponse;
+			if (!finalQuote) {
+				finalQuote = await jupiterClient.getQuote({
+					inputMint,
+					outputMint,
+					amount,
+					slippageBps,
+					swapMode,
+					onlyDirectRoutes,
+				});
+			}
+
+			if (!finalQuote) {
+				throw new Error('Could not fetch swap quote. Please try again.');
+			}
+
+			// Get swap transaction and extract instructions
+			const transaction = await jupiterClient.getSwap({
+				quote: finalQuote,
+				userPublicKey,
+				slippageBps,
+			});
+
+			const { transactionMessage, lookupTables: jupiterLookupTables } =
+				await jupiterClient.getTransactionMessageAndLookupTables({
+					transaction,
+				});
+
+			swapInstructions = jupiterClient.getJupiterInstructions({
+				transactionMessage,
+				inputMint,
+				outputMint,
+			});
+
+			lookupTables = jupiterLookupTables;
+		} else {
+			const titanClient = this.client as TitanClient;
+
+			// For Titan, get swap directly (it handles quote internally)
+			const { transactionMessage, lookupTables: titanLookupTables } =
+				await titanClient.getSwap({
+					inputMint,
+					outputMint,
+					amount,
+					userPublicKey,
+					slippageBps,
+					swapMode: isExactOut ? TitanSwapMode.ExactOut : TitanSwapMode.ExactIn,
+					onlyDirectRoutes,
+					sizeConstraint: sizeConstraint || 1280 - 375, // MAX_TX_BYTE_SIZE - buffer for drift instructions
+				});
+
+			swapInstructions = titanClient.getTitanInstructions({
+				transactionMessage,
+				inputMint,
+				outputMint,
+			});
+
+			lookupTables = titanLookupTables;
+		}
+
+		return { instructions: swapInstructions, lookupTables };
+	}
+
+	/**
+	 * Get the underlying client instance
+	 */
+	public getClient(): JupiterClient | TitanClient {
+		return this.client;
+	}
+
+	/**
+	 * Get the client type
+	 */
+	public getClientType(): SwapClientType {
+		return this.clientType;
+	}
+
+	/**
+	 * Check if this is a Jupiter client
+	 */
+	public isJupiter(): boolean {
+		return this.clientType === 'jupiter';
+	}
+
+	/**
+	 * Check if this is a Titan client
+	 */
+	public isTitan(): boolean {
+		return this.clientType === 'titan';
+	}
+}

package/src/swift/grpcSignedMsgUserAccountSubscriber.ts

@@ -0,0 +1,95 @@
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
+import { GrpcConfigs, ResubOpts } from '../accounts/types';
+import { SignedMsgUserOrdersAccount } from '../types';
+import { getSignedMsgUserOrdersFilter } from '../memcmp';
+import { SignedMsgUserOrdersAccountSubscriber } from './signedMsgUserAccountSubscriber';
+import { VelocityClient } from '../velocityClient';
+
+export class grpcSignedMsgUserOrdersAccountSubscriber extends SignedMsgUserOrdersAccountSubscriber {
+	private grpcConfigs: GrpcConfigs;
+	override subscriber: grpcProgramAccountSubscriber<SignedMsgUserOrdersAccount>;
+
+	constructor({
+		grpcConfigs,
+		driftClient,
+		commitment,
+		resubOpts,
+		decodeFn,
+		resyncIntervalMs,
+	}: {
+		grpcConfigs: GrpcConfigs;
+		driftClient: VelocityClient;
+		commitment?: Commitment;
+		resubOpts?: ResubOpts;
+		decodeFn?: (name: string, data: Buffer) => SignedMsgUserOrdersAccount;
+		resyncIntervalMs?: number;
+	}) {
+		super({
+			driftClient,
+			commitment,
+			resubOpts,
+			decodeFn,
+			resyncIntervalMs,
+		});
+		this.grpcConfigs = grpcConfigs;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (!this.subscriber) {
+			this.subscriber =
+				await grpcProgramAccountSubscriber.create<SignedMsgUserOrdersAccount>(
+					this.grpcConfigs,
+					'SingedMsgUserOrdersAccountMap',
+					'signedMsgUserOrders',
+					this.driftClient.program,
+					this.decodeFn,
+					{
+						filters: [getSignedMsgUserOrdersFilter()],
+					},
+					this.resubOpts
+				);
+		}
+
+		await this.subscriber.subscribe(
+			(
+				_accountId: PublicKey,
+				account: SignedMsgUserOrdersAccount,
+				context: Context
+			) => {
+				this.tryUpdateSignedMsgUserOrdersAccount(
+					account,
+					'decoded',
+					context.slot
+				);
+			}
+		);
+
+		if (this.resyncIntervalMs) {
+			const recursiveResync = () => {
+				this.resyncTimeoutId = setTimeout(() => {
+					this.fetch()
+						.catch((e) => {
+							console.error('Failed to resync in OrderSubscriber');
+							console.log(e);
+						})
+						.finally(() => {
+							if (!this.resyncTimeoutId) return;
+							recursiveResync();
+						});
+				}, this.resyncIntervalMs);
+			};
+			recursiveResync();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscriber) return;
+		await this.subscriber.unsubscribe();
+		this.subscriber = undefined;
+		if (this.resyncTimeoutId !== undefined) {
+			clearTimeout(this.resyncTimeoutId);
+			this.resyncTimeoutId = undefined;
+		}
+	}
+}

package/src/swift/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Swift / signed-message order infrastructure.
+ * Supports off-chain signed order messages that are matched and settled on-chain without
+ * a separate place-order transaction. Used for low-latency taker flows.
+ * `swiftOrderSubscriber.ts` — subscribes to incoming Swift orders via gRPC or WebSocket.
+ * `signedMsgUserAccountSubscriber.ts` — caches signed-message user account state.
+ */
+export * from './swiftOrderSubscriber';
+export * from './signedMsgUserAccountSubscriber';
+export * from './grpcSignedMsgUserAccountSubscriber';