@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/swift/signedMsgUserAccountSubscriber.ts

@@ -1,251 +0,0 @@
-import { getSignedMsgUserOrdersFilter } from '../memcmp';
-import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
-import { SignedMsgOrderId, SignedMsgUserOrdersAccount } from '../types';
-import { Commitment, Context, PublicKey } from '@solana/web3.js';
-import { ResubOpts } from '../accounts/types';
-import { VelocityClient } from '../velocityClient';
-import StrictEventEmitter from 'strict-event-emitter-types';
-import { EventEmitter } from 'events';
-
-export type SignedMsgUserOrdersAccountSubscriberConfig = {
-	commitment?: Commitment;
-	resubOpts?: ResubOpts;
-	decodeFn?: (name: string, data: Buffer) => SignedMsgUserOrdersAccount;
-	resyncIntervalMs?: number;
-} & { velocityClient: VelocityClient };
-
-export interface SignedMsgUserOrdersAccountSubscriberEvents {
-	onAccountUpdate: (
-		activeSignedMsgOrderIds: SignedMsgOrderId[],
-		authorityPubkey: PublicKey,
-		slot: number
-	) => void;
-
-	newSignedMsgOrderIds: (
-		newSignedMsgOrderIds: SignedMsgOrderId[],
-		authorityPubkey: PublicKey,
-		slot: number
-	) => void;
-}
-
-export class SignedMsgUserOrdersAccountSubscriber {
-	protected velocityClient: VelocityClient;
-	protected commitment: Commitment;
-	protected resubOpts?: ResubOpts;
-	protected resyncTimeoutId?: ReturnType<typeof setTimeout>;
-	protected resyncIntervalMs?: number;
-	protected decodeFn: (
-		name: string,
-		data: Buffer
-	) => SignedMsgUserOrdersAccount;
-	public signedMsgUserOrderAccounts = new Map<
-		string,
-		{ slot: number; signedMsgUserOrdersAccount: SignedMsgUserOrdersAccount }
-	>();
-	mostRecentSlot = 0;
-
-	fetchPromise?: Promise<void>;
-	private fetchPromiseResolver: () => void = () => {};
-
-	protected _subscriber?: WebSocketProgramAccountSubscriber<SignedMsgUserOrdersAccount>;
-	protected get subscriber(): WebSocketProgramAccountSubscriber<SignedMsgUserOrdersAccount> {
-		if (!this._subscriber) {
-			throw new Error(
-				'SignedMsgUserOrdersAccountSubscriber: subscriber accessed before subscribe()'
-			);
-		}
-		return this._subscriber;
-	}
-	public eventEmitter: StrictEventEmitter<
-		EventEmitter,
-		SignedMsgUserOrdersAccountSubscriberEvents
-	>;
-
-	constructor({
-		velocityClient,
-		commitment,
-		resubOpts,
-		decodeFn,
-		resyncIntervalMs,
-	}: SignedMsgUserOrdersAccountSubscriberConfig) {
-		this.commitment = commitment ?? 'confirmed';
-		this.resubOpts = resubOpts;
-		// Type-system guarantees at least one of the two is supplied.
-		this.velocityClient = velocityClient!;
-		this.decodeFn =
-			decodeFn ??
-			(
-				this.velocityClient.program.account as any
-			).signedMsgUserOrders.coder.accounts.decodeUnchecked.bind(
-				(this.velocityClient.program.account as any).signedMsgUserOrders.coder
-					.accounts
-			);
-		this.resyncIntervalMs = resyncIntervalMs;
-		this.eventEmitter = new EventEmitter();
-		this.resubOpts = resubOpts;
-	}
-
-	public async subscribe(): Promise<void> {
-		if (!this._subscriber) {
-			const filters = [getSignedMsgUserOrdersFilter()];
-			this._subscriber =
-				new WebSocketProgramAccountSubscriber<SignedMsgUserOrdersAccount>(
-					'SingedMsgUserOrdersAccountMap',
-					'signedMsgUserOrders',
-					this.velocityClient.program,
-					this.decodeFn,
-					{
-						filters,
-						commitment: this.commitment,
-					},
-					this.resubOpts
-				);
-		}
-
-		await this.subscriber.subscribe(
-			(
-				_accountId: PublicKey,
-				account: SignedMsgUserOrdersAccount,
-				context: Context
-			) => {
-				this.tryUpdateSignedMsgUserOrdersAccount(
-					account,
-					'decoded',
-					context.slot
-				);
-			}
-		);
-
-		await this.fetch();
-
-		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();
-		}
-	}
-
-	async fetch(): Promise<void> {
-		if (this.fetchPromise) {
-			return this.fetchPromise;
-		}
-
-		this.fetchPromise = new Promise((resolver) => {
-			this.fetchPromiseResolver = resolver;
-		});
-
-		const skipEventEmitting = this.signedMsgUserOrderAccounts.size === 0;
-
-		try {
-			const rpcResponseAndContext =
-				await this.velocityClient.connection.getProgramAccounts(
-					this.velocityClient.program.programId,
-					{
-						commitment: this.commitment,
-						filters: [getSignedMsgUserOrdersFilter()],
-						encoding: 'base64',
-						withContext: true,
-					}
-				);
-
-			const slot: number = rpcResponseAndContext.context.slot;
-
-			for (const programAccount of rpcResponseAndContext.value) {
-				this.tryUpdateSignedMsgUserOrdersAccount(
-					programAccount.account.data,
-					'buffer',
-					slot,
-					skipEventEmitting
-				);
-				await new Promise((resolve) => setTimeout(resolve, 0));
-			}
-		} catch (e) {
-			console.error(e);
-		} finally {
-			this.fetchPromiseResolver();
-			this.fetchPromise = undefined;
-		}
-	}
-
-	tryUpdateSignedMsgUserOrdersAccount(
-		data: Buffer | SignedMsgUserOrdersAccount,
-		dataType: 'buffer' | 'decoded',
-		slot: number,
-		skipEventEmitting = false
-	): void {
-		if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
-			this.mostRecentSlot = slot;
-		}
-
-		const signedMsgUserOrdersAccount =
-			dataType === 'buffer'
-				? this.decodeFn('signedMsgUserOrders', data as Buffer)
-				: (data as SignedMsgUserOrdersAccount);
-
-		const key = signedMsgUserOrdersAccount.authorityPubkey.toBase58();
-
-		const slotAndSignedMsgUserOrdersAccount =
-			this.signedMsgUserOrderAccounts.get(key);
-		if (
-			!slotAndSignedMsgUserOrdersAccount ||
-			slotAndSignedMsgUserOrdersAccount.slot <= slot
-		) {
-			if (!skipEventEmitting) {
-				this.eventEmitter.emit(
-					'onAccountUpdate',
-					signedMsgUserOrdersAccount.signedMsgOrderData.filter(
-						(signedMsgOrderId) => signedMsgOrderId.orderId !== 0
-					),
-					signedMsgUserOrdersAccount.authorityPubkey,
-					slot
-				);
-			}
-
-			const existingSignedMsgOrderIds =
-				slotAndSignedMsgUserOrdersAccount?.signedMsgUserOrdersAccount.signedMsgOrderData.map(
-					(signedMsgOrderId) => signedMsgOrderId.orderId
-				) ?? [];
-
-			const newSignedMsgOrderIds =
-				signedMsgUserOrdersAccount.signedMsgOrderData.filter(
-					(signedMsgOrderId: SignedMsgOrderId) =>
-						!existingSignedMsgOrderIds.includes(signedMsgOrderId.orderId) &&
-						signedMsgOrderId.orderId !== 0
-				);
-			if (newSignedMsgOrderIds.length > 0 && !skipEventEmitting) {
-				this.eventEmitter.emit(
-					'newSignedMsgOrderIds',
-					newSignedMsgOrderIds,
-					signedMsgUserOrdersAccount.authorityPubkey,
-					slot
-				);
-			}
-
-			this.signedMsgUserOrderAccounts.set(key, {
-				slot,
-				signedMsgUserOrdersAccount,
-			});
-		}
-	}
-
-	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/swiftOrderSubscriber.ts

@@ -1,351 +0,0 @@
-import {
-	DevnetPerpMarkets,
-	MainnetPerpMarkets,
-} from '../constants/perpMarkets';
-import { VelocityClient } from '../velocityClient';
-import { VelocityEnv } from '../config';
-import {
-	getUserAccountPublicKey,
-	getUserStatsAccountPublicKey,
-} from '../addresses/pda';
-import {
-	MarketType,
-	OptionalOrderParams,
-	PostOnlyParams,
-	SignedMsgOrderParamsDelegateMessage,
-	SignedMsgOrderParamsMessage,
-	UserAccount,
-} from '../types';
-import { Keypair, PublicKey, TransactionInstruction } from '@solana/web3.js';
-import nacl from 'tweetnacl';
-import { decodeUTF8 } from 'tweetnacl-util';
-import WebSocket from 'ws';
-import { sha256 } from '@noble/hashes/sha256';
-
-// In practice, this for now is just an OrderSubscriber or a UserMap
-export interface AccountGetter {
-	mustGetUserAccount(publicKey: string): Promise<UserAccount>;
-}
-
-type SwiftOrderSubscriberConfigBase = {
-	userAccountGetter?: AccountGetter;
-	endpoint?: string;
-	marketIndexes: number[];
-	/**
-		In the future, this will be used for verifying $VELOCITY stake as we add
-		authentication for delegate signers
-		For now, pass a new keypair or a keypair to an empty wallet
-	*/
-	keypair: Keypair;
-};
-
-export type SwiftOrderSubscriberConfig = SwiftOrderSubscriberConfigBase & {
-	velocityEnv: VelocityEnv;
-} & { velocityClient: VelocityClient };
-
-/**
- * Swift order message received from WebSocket
- */
-export interface SwiftOrderMessage {
-	/** Hex string of the order message */
-	order_message: string;
-	/** Base58 string of taker authority */
-	taker_authority: string;
-	/** Base58 string of signing authority */
-	signing_authority: string;
-	/** Base64 string containing the order signature */
-	order_signature: string;
-	/** Swift order UUID */
-	uuid: string;
-	/** Whether the order auction params are likely to be sanitized on submission to program */
-	will_sanitize?: boolean;
-	/** Base64 string of a prerequisite deposit tx. The swift order_message should be bundled
-	 * after the deposit when present  */
-	depositTx?: string;
-	/** order market index */
-	market_index: number;
-	/** order timestamp in unix ms */
-	ts: number;
-}
-
-export class SwiftOrderSubscriber {
-	private heartbeatTimeout: ReturnType<typeof setTimeout> | null = null;
-	private readonly heartbeatIntervalMs = 60000;
-	private ws: WebSocket | null = null;
-	private velocityClient: VelocityClient;
-	public userAccountGetter?: AccountGetter; // In practice, this for now is just an OrderSubscriber or a UserMap
-	public onOrder?: (
-		orderMessageRaw: SwiftOrderMessage,
-		signedMessage:
-			| SignedMsgOrderParamsMessage
-			| SignedMsgOrderParamsDelegateMessage,
-		isDelegateSigner?: boolean
-	) => Promise<void>;
-
-	subscribed = false;
-
-	constructor(private config: SwiftOrderSubscriberConfig) {
-		// Type-system guarantees at least one of the two is supplied.
-		this.velocityClient = config.velocityClient!;
-		this.userAccountGetter = config.userAccountGetter;
-	}
-
-	unsubscribe() {
-		if (this.subscribed) {
-			this.ws?.removeAllListeners();
-			this.ws?.terminate();
-			this.ws = null;
-			this.subscribed = false;
-		}
-	}
-
-	getSymbolForMarketIndex(marketIndex: number): string {
-		const env = this.config.velocityEnv;
-		const markets = env === 'devnet' ? DevnetPerpMarkets : MainnetPerpMarkets;
-		return markets[marketIndex].symbol;
-	}
-
-	generateChallengeResponse(nonce: string): string {
-		const messageBytes = decodeUTF8(nonce);
-		const signature = nacl.sign.detached(
-			messageBytes,
-			this.config.keypair.secretKey
-		);
-		const signatureBase64 = Buffer.from(signature).toString('base64');
-		return signatureBase64;
-	}
-
-	handleAuthMessage(message: any): void {
-		if (message['channel'] === 'auth' && message['nonce'] != null) {
-			const signatureBase64 = this.generateChallengeResponse(message['nonce']);
-			this.ws?.send(
-				JSON.stringify({
-					pubkey: this.config.keypair.publicKey.toBase58(),
-					signature: signatureBase64,
-				})
-			);
-		}
-
-		if (
-			message['channel'] === 'auth' &&
-			message['message']?.toLowerCase() === 'authenticated'
-		) {
-			this.subscribed = true;
-			this.config.marketIndexes.forEach(async (marketIndex) => {
-				this.ws?.send(
-					JSON.stringify({
-						action: 'subscribe',
-						market_type: 'perp',
-						market_name: this.getSymbolForMarketIndex(marketIndex),
-					})
-				);
-				await new Promise((resolve) => setTimeout(resolve, 100));
-			});
-		}
-	}
-
-	async subscribe(
-		onOrder: (
-			orderMessageRaw: SwiftOrderMessage,
-			signedMessage:
-				| SignedMsgOrderParamsMessage
-				| SignedMsgOrderParamsDelegateMessage,
-			isDelegateSigner?: boolean
-		) => Promise<void>,
-		acceptSanitized = false,
-		acceptDepositTrade = false
-	): Promise<void> {
-		this.onOrder = onOrder;
-
-		const env = this.config.velocityEnv;
-		const endpoint =
-			this.config.endpoint ??
-			(env === 'devnet'
-				? 'wss://swift.master.velocity.exchange/ws'
-				: 'wss://swift.velocity.exchange/ws');
-		const ws = new WebSocket(
-			endpoint + '?pubkey=' + this.config.keypair.publicKey.toBase58()
-		);
-		this.ws = ws;
-		ws.on('open', async () => {
-			console.log('Connected to the server');
-
-			ws.on('message', async (data: WebSocket.Data) => {
-				const message = JSON.parse(data.toString());
-				this.startHeartbeatTimer();
-
-				if (message['channel'] === 'auth') {
-					this.handleAuthMessage(message);
-				}
-
-				if (message['order']) {
-					const order = message['order'] as SwiftOrderMessage;
-					// ignore likely sanitized orders by default
-					if (order.will_sanitize === true && !acceptSanitized) {
-						return;
-					}
-					// order has a prerequisite deposit tx attached
-					if (message['deposit']) {
-						order.depositTx = message['deposit'];
-						if (!acceptDepositTrade) {
-							return;
-						}
-					}
-					const signedMsgOrderParamsBuf = Buffer.from(
-						order.order_message,
-						'hex'
-					);
-					const isDelegateSigner = signedMsgOrderParamsBuf
-						.slice(0, 8)
-						.equals(
-							Uint8Array.from(
-								Buffer.from(
-									sha256('global' + ':' + 'SignedMsgOrderParamsDelegateMessage')
-								).slice(0, 8)
-							)
-						);
-					const signedMessage =
-						this.velocityClient.decodeSignedMsgOrderParamsMessage(
-							signedMsgOrderParamsBuf,
-							isDelegateSigner
-						);
-
-					if (!signedMessage.signedMsgOrderParams.price) {
-						console.error(
-							`order has no price: ${JSON.stringify(
-								signedMessage.signedMsgOrderParams
-							)}`
-						);
-						return;
-					}
-
-					onOrder(order, signedMessage, isDelegateSigner);
-				}
-			});
-
-			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);
-				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);
-				this.reconnect();
-			}, 1000);
-		});
-	}
-
-	async getPlaceAndMakeSignedMsgOrderIxs(
-		orderMessageRaw: SwiftOrderMessage,
-		signedMsgOrderParamsMessage:
-			| SignedMsgOrderParamsMessage
-			| SignedMsgOrderParamsDelegateMessage,
-		makerOrderParams: OptionalOrderParams
-	): Promise<TransactionInstruction[]> {
-		if (!this.userAccountGetter) {
-			throw new Error('userAccountGetter must be set to use this function');
-		}
-
-		const signedMsgOrderParamsBuf = Buffer.from(
-			orderMessageRaw.order_message,
-			'hex'
-		);
-
-		const isDelegateSigner = signedMsgOrderParamsBuf
-			.slice(0, 8)
-			.equals(
-				Uint8Array.from(
-					Buffer.from(
-						sha256('global' + ':' + 'SignedMsgOrderParamsDelegateMessage')
-					).slice(0, 8)
-				)
-			);
-		const signedMessage = this.velocityClient.decodeSignedMsgOrderParamsMessage(
-			signedMsgOrderParamsBuf,
-			isDelegateSigner
-		);
-
-		const takerAuthority = new PublicKey(orderMessageRaw.taker_authority);
-		const signingAuthority = new PublicKey(orderMessageRaw.signing_authority);
-		const takerUserPubkey = isDelegateSigner
-			? (signedMessage as SignedMsgOrderParamsDelegateMessage).takerPubkey
-			: await getUserAccountPublicKey(
-					this.velocityClient.program.programId,
-					takerAuthority,
-					(signedMessage as SignedMsgOrderParamsMessage).subAccountId
-			  );
-		const takerUserAccount = await this.userAccountGetter.mustGetUserAccount(
-			takerUserPubkey.toString()
-		);
-		const ixs = await this.velocityClient.getPlaceAndMakeSignedMsgPerpOrderIxs(
-			{
-				orderParams: signedMsgOrderParamsBuf,
-				signature: Buffer.from(orderMessageRaw.order_signature, 'base64'),
-			},
-			decodeUTF8(orderMessageRaw.uuid),
-			{
-				taker: takerUserPubkey,
-				takerUserAccount,
-				takerStats: getUserStatsAccountPublicKey(
-					this.velocityClient.program.programId,
-					takerUserAccount.authority
-				),
-				signingAuthority: signingAuthority,
-			},
-			Object.assign({}, makerOrderParams, {
-				postOnly: PostOnlyParams.MUST_POST_ONLY,
-				immediateOrCancel: true,
-				marketType: MarketType.PERP,
-			})
-		);
-		return ixs;
-	}
-
-	private startHeartbeatTimer() {
-		if (this.heartbeatTimeout) {
-			clearTimeout(this.heartbeatTimeout);
-		}
-		if (!this.onOrder) {
-			throw new Error('onOrder callback function must be set');
-		}
-		this.heartbeatTimeout = setTimeout(() => {
-			console.warn('No heartbeat received within 30 seconds, reconnecting...');
-			this.reconnect();
-		}, this.heartbeatIntervalMs);
-	}
-
-	private reconnect() {
-		if (this.ws) {
-			this.ws.removeAllListeners();
-			this.ws.terminate();
-		}
-
-		console.log('Reconnecting to WebSocket...');
-		const onOrder = this.onOrder;
-		if (!onOrder) {
-			throw new Error('onOrder callback function must be set');
-		}
-		setTimeout(() => {
-			this.subscribe(onOrder);
-		}, 1000);
-	}
-}

package/src/testClient.ts

@@ -1,42 +0,0 @@
-import { AdminClient } from './adminClient';
-import { ConfirmOptions, Signer, Transaction } from '@solana/web3.js';
-import { TxSigAndSlot } from './tx/types';
-import { PollingVelocityClientAccountSubscriber } from './accounts/pollingVelocityClientAccountSubscriber';
-import { VelocityClientConfig } from './velocityClientConfig';
-
-export class TestClient extends AdminClient {
-	public constructor(config: VelocityClientConfig) {
-		config.txVersion = 'legacy';
-		if (config.accountSubscription?.type !== 'polling') {
-			throw new Error('Test client must be polling');
-		}
-		super(config);
-	}
-
-	async sendTransaction(
-		tx: Transaction,
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions,
-		preSigned?: boolean
-	): Promise<TxSigAndSlot> {
-		const { txSig, slot } = await super.sendTransaction(
-			tx,
-			additionalSigners,
-			opts,
-			preSigned
-		);
-
-		let lastFetchedSlot = (
-			this.accountSubscriber as PollingVelocityClientAccountSubscriber
-		).accountLoader.mostRecentSlot;
-		await this.fetchAccounts();
-		while (slot !== undefined && lastFetchedSlot < slot) {
-			await this.fetchAccounts();
-			lastFetchedSlot = (
-				this.accountSubscriber as PollingVelocityClientAccountSubscriber
-			).accountLoader.mostRecentSlot;
-		}
-
-		return { txSig, slot };
-	}
-}