@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/pyth/utils.ts

@@ -1,13 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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
-
-/** Events emitted on `SlotSubscriber.eventEmitter`. */
-export interface SlotSubscriberEvents {
-	/** Fired whenever a new, strictly-greater slot is observed (including the initial slot fetched by `subscribe()`). */
-	newSlot: (newSlot: number) => void;
-}
-
-/**
- * SlotSubscriber — tracks the current slot via `connection.onSlotChange`,
- * with an optional stall-detection resubscribe. Slot updates that are not
- * strictly greater than the currently tracked slot are ignored (protects
- * against out-of-order delivery).
- */
-export class SlotSubscriber {
-	currentSlot = 0;
-	subscriptionId?: number;
-	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
-
-	// Reconnection
-	timeoutId?: ReturnType<typeof setTimeout>;
-	resubTimeoutMs?: number;
-	isUnsubscribing = false;
-	receivingData = false;
-
-	/**
-	 * @param connection RPC connection to subscribe on.
-	 * @param config.resubTimeoutMs If set to a positive value, resubscribe when no slot update arrives for this many ms; `0` (or unset) disables the resubscribe watchdog. Positive values below 1000ms log a warning (too aggressive) but are still honored.
-	 */
-	public constructor(
-		private connection: Connection,
-		config?: SlotSubscriberConfig
-	) {
-		this.eventEmitter = new EventEmitter();
-		this.resubTimeoutMs = config?.resubTimeoutMs;
-		if (this.resubTimeoutMs !== undefined && this.resubTimeoutMs < 1000) {
-			console.log(
-				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
-			);
-		}
-	}
-
-	/** Fetches the current slot once via RPC, then subscribes to `onSlotChange` for live updates. Idempotent while already subscribed. */
-	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);
-	}
-
-	/** @returns The most recently observed slot, or `0` if `subscribe()` hasn't completed yet. */
-	public getSlot(): number {
-		return this.currentSlot;
-	}
-
-	/**
-	 * Removes the `onSlotChange` listener and cancels the resub timeout.
-	 * @param onResub Internal flag used when unsubscribing as part of an automatic resubscribe cycle; when `false` (a caller-initiated unsubscribe), also permanently disables future auto-resubscribe by clearing `resubTimeoutMs`.
-	 */
-	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

@@ -1,163 +0,0 @@
-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
-
-/** A slot and its corresponding blockhash, decoded from the `SysvarS1otHashes111111111111111111111111111` account. */
-export type Slothash = {
-	slot: number;
-	/** Base58-encoded blockhash for that slot. */
-	hash: string;
-};
-
-/**
- * SlothashSubscriber — tracks the most recent entry of the `SlotHashes`
- * sysvar via `connection.onAccountChange`, with an optional stall-detection
- * resubscribe. Updates whose slot is not strictly greater than the currently
- * tracked one are ignored.
- */
-export class SlothashSubscriber {
-	private _currentSlothash?: Slothash;
-	private get currentSlothash(): Slothash {
-		if (!this._currentSlothash) {
-			throw new Error(
-				'SlothashSubscriber: slothash accessed before subscribe()'
-			);
-		}
-		return this._currentSlothash;
-	}
-	subscriptionId?: number;
-	commitment: Commitment;
-
-	// Reconnection
-	timeoutId?: ReturnType<typeof setTimeout>;
-	resubTimeoutMs?: number;
-	isUnsubscribing = false;
-	receivingData = false;
-
-	/**
-	 * @param connection RPC connection to subscribe on.
-	 * @param config.commitment Commitment for both the initial fetch and the account-change subscription; defaults to `'processed'`.
-	 * @param config.resubTimeoutMs If set to a positive value, resubscribe when no update arrives for this many ms; `0` (or unset) disables the resubscribe watchdog. Positive values below 1000ms log a warning but are still honored.
-	 */
-	public constructor(
-		private connection: Connection,
-		config?: SlothashSubscriberConfig
-	) {
-		this.resubTimeoutMs = config?.resubTimeoutMs;
-		this.commitment = config?.commitment ?? 'processed';
-		if (this.resubTimeoutMs != null && this.resubTimeoutMs < 1000) {
-			console.log(
-				'resubTimeoutMs should be at least 1000ms to avoid spamming resub'
-			);
-		}
-	}
-
-	/**
-	 * Fetches the `SlotHashes` sysvar once via RPC, then subscribes to
-	 * `onAccountChange` for live updates. Idempotent while already subscribed.
-	 * @throws If the sysvar account can't be fetched on the initial load.
-	 */
-	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);
-	}
-
-	/**
-	 * @returns The most recently observed `Slothash`.
-	 * @throws If called before `subscribe()` has completed its initial fetch.
-	 */
-	public getSlothash(): Slothash {
-		return this.currentSlothash;
-	}
-
-	/**
-	 * Removes the `onAccountChange` listener and cancels the resub timeout.
-	 * @param onResub Internal flag used when unsubscribing as part of an automatic resubscribe cycle; when `false`, also permanently disables future auto-resubscribe by clearing `resubTimeoutMs`.
-	 */
-	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.removeAccountChangeListener(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

@@ -1,315 +0,0 @@
-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 velocity 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

@@ -1,81 +0,0 @@
-import { Context, PublicKey } from '@solana/web3.js';
-import { grpcProgramAccountSubscriber } from '../accounts/grpcProgramAccountSubscriber';
-import { GrpcConfigs } from '../accounts/types';
-import { SignedMsgUserOrdersAccount } from '../types';
-import { getSignedMsgUserOrdersFilter } from '../memcmp';
-import {
-	SignedMsgUserOrdersAccountSubscriber,
-	SignedMsgUserOrdersAccountSubscriberConfig,
-} from './signedMsgUserAccountSubscriber';
-
-export class grpcSignedMsgUserOrdersAccountSubscriber extends SignedMsgUserOrdersAccountSubscriber {
-	private grpcConfigs: GrpcConfigs;
-
-	constructor({
-		grpcConfigs,
-		...rest
-	}: SignedMsgUserOrdersAccountSubscriberConfig & {
-		grpcConfigs: GrpcConfigs;
-	}) {
-		super(rest);
-		this.grpcConfigs = grpcConfigs;
-	}
-
-	public async subscribe(): Promise<void> {
-		if (!this._subscriber) {
-			this._subscriber =
-				await grpcProgramAccountSubscriber.create<SignedMsgUserOrdersAccount>(
-					this.grpcConfigs,
-					'SingedMsgUserOrdersAccountMap',
-					'signedMsgUserOrders',
-					this.velocityClient.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

@@ -1,10 +0,0 @@
-/**
- * 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';