@velocity-exchange/sdk 0.0.1

package/src/velocityClientConfig.ts

@@ -0,0 +1,144 @@
+/**
+ * VelocityClientConfig — configuration types for constructing a {@link VelocityClient}.
+ *
+ * Key options: RPC connection, wallet/keypair, account subscription mode
+ * (WebSocket vs polling), oracle client selection, transaction sender config,
+ * and feature flags (activeSubAccountId, authority override).
+ */
+import {
+	Commitment,
+	ConfirmOptions,
+	Connection,
+	PublicKey,
+	TransactionVersion,
+} from '@solana/web3.js';
+import { IWallet, TxParams, UserAccount } from './types';
+import { OracleInfo } from './oracles/types';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { VelocityEnv } from './config';
+import { TxSender } from './tx/types';
+import { TxHandler, TxHandlerConfig } from './tx/txHandler';
+import {
+	GrpcConfigs,
+	ResubOpts,
+	DelistedMarketSetting,
+} from './accounts/types';
+import { Coder, Program } from './isomorphic/anchor';
+import { WebSocketAccountSubscriber } from './accounts/webSocketAccountSubscriber';
+import { WebSocketAccountSubscriberV2 } from './accounts/webSocketAccountSubscriberV2';
+import { grpcVelocityClientAccountSubscriberV2 } from './accounts/grpcVelocityClientAccountSubscriberV2';
+import { grpcVelocityClientAccountSubscriber } from './accounts/grpcVelocityClientAccountSubscriber';
+import { grpcMultiUserAccountSubscriber } from './accounts/grpcMultiUserAccountSubscriber';
+import { WebSocketProgramAccountSubscriber } from './accounts/webSocketProgramAccountSubscriber';
+import { WebSocketVelocityClientAccountSubscriber } from './accounts/webSocketVelocityClientAccountSubscriber';
+import { WebSocketVelocityClientAccountSubscriberV2 } from './accounts/webSocketVelocityClientAccountSubscriberV2';
+
+export type VelocityClientConfig = {
+	connection: Connection;
+	wallet: IWallet;
+	env?: VelocityEnv;
+	programID?: PublicKey;
+	accountSubscription?: VelocityClientSubscriptionConfig;
+	opts?: ConfirmOptions;
+	txSender?: TxSender;
+	txHandler?: TxHandler;
+	subAccountIds?: number[];
+	activeSubAccountId?: number;
+	perpMarketIndexes?: number[];
+	spotMarketIndexes?: number[];
+	/** @deprecated use marketLookupTables */
+	marketLookupTable?: PublicKey;
+	marketLookupTables?: PublicKey[];
+	oracleInfos?: OracleInfo[];
+	userStats?: boolean;
+	authority?: PublicKey; // explicitly pass an authority if signer is delegate
+	includeDelegates?: boolean; // flag for whether to load delegate accounts as well
+	authoritySubAccountMap?: Map<string, number[]>; // if passed this will override subAccountIds and includeDelegates
+	skipLoadUsers?: boolean; // if passed to constructor, no user accounts will be loaded. they will load if updateWallet is called afterwards.
+	txVersion?: TransactionVersion; // which tx version to use
+	txParams?: TxParams; // default tx params to use
+	enableMetricsEvents?: boolean;
+	txHandlerConfig?: TxHandlerConfig;
+	delistedMarketSetting?: DelistedMarketSetting;
+	useHotWalletAdmin?: boolean;
+	coder?: Coder;
+};
+
+/** @deprecated Use `VelocityClientConfig` instead. `DriftClientConfig` will be removed in a future major. */
+export type DriftClientConfig = VelocityClientConfig;
+
+export type VelocityClientSubscriptionConfig =
+	| {
+			type: 'grpc';
+			grpcConfigs: GrpcConfigs;
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			velocityClientAccountSubscriber?: new (
+				grpcConfigs: GrpcConfigs,
+				program: Program,
+				perpMarketIndexes: number[],
+				spotMarketIndexes: number[],
+				oracleInfos: OracleInfo[],
+				shouldFindAllMarketsAndOracles: boolean,
+				delistedMarketSetting: DelistedMarketSetting
+			) =>
+				| grpcVelocityClientAccountSubscriberV2
+				| grpcVelocityClientAccountSubscriber;
+			/** @deprecated Use `velocityClientAccountSubscriber` instead. `driftClientAccountSubscriber` will be removed in a future major. */
+			driftClientAccountSubscriber?: new (
+				grpcConfigs: GrpcConfigs,
+				program: Program,
+				perpMarketIndexes: number[],
+				spotMarketIndexes: number[],
+				oracleInfos: OracleInfo[],
+				shouldFindAllMarketsAndOracles: boolean,
+				delistedMarketSetting: DelistedMarketSetting
+			) =>
+				| grpcVelocityClientAccountSubscriberV2
+				| grpcVelocityClientAccountSubscriber;
+			grpcMultiUserAccountSubscriber?: grpcMultiUserAccountSubscriber;
+	  }
+	| {
+			type: 'websocket';
+			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
+			commitment?: Commitment;
+			programUserAccountSubscriber?: WebSocketProgramAccountSubscriber<UserAccount>;
+			perpMarketAccountSubscriber?: new (
+				accountName: string,
+				program: Program,
+				accountPublicKey: PublicKey,
+				decodeBuffer?: (buffer: Buffer) => any,
+				resubOpts?: ResubOpts,
+				commitment?: Commitment
+			) => WebSocketAccountSubscriberV2<any> | WebSocketAccountSubscriber<any>;
+			/** If you use V2 here, whatever you pass for perpMarketAccountSubscriber will be ignored and it will use v2 under the hood regardless */
+			velocityClientAccountSubscriber?: new (
+				program: Program,
+				perpMarketIndexes: number[],
+				spotMarketIndexes: number[],
+				oracleInfos: OracleInfo[],
+				shouldFindAllMarketsAndOracles: boolean,
+				delistedMarketSetting: DelistedMarketSetting
+			) =>
+				| WebSocketVelocityClientAccountSubscriber
+				| WebSocketVelocityClientAccountSubscriberV2;
+			/** @deprecated Use `velocityClientAccountSubscriber` instead. `driftClientAccountSubscriber` will be removed in a future major. */
+			driftClientAccountSubscriber?: new (
+				program: Program,
+				perpMarketIndexes: number[],
+				spotMarketIndexes: number[],
+				oracleInfos: OracleInfo[],
+				shouldFindAllMarketsAndOracles: boolean,
+				delistedMarketSetting: DelistedMarketSetting
+			) =>
+				| WebSocketVelocityClientAccountSubscriber
+				| WebSocketVelocityClientAccountSubscriberV2;
+	  }
+	| {
+			type: 'polling';
+			accountLoader: BulkAccountLoader;
+	  };
+
+/** @deprecated Use `VelocityClientSubscriptionConfig` instead. `DriftClientSubscriptionConfig` will be removed in a future major. */
+export type DriftClientSubscriptionConfig = VelocityClientSubscriptionConfig;

package/src/wallet.ts

@@ -0,0 +1,54 @@
+import {
+	Keypair,
+	PublicKey,
+	Transaction,
+	VersionedTransaction,
+} from '@solana/web3.js';
+import { IWallet, IVersionedWallet } from './types';
+import nacl from 'tweetnacl';
+
+export class Wallet implements IWallet, IVersionedWallet {
+	constructor(readonly payer: Keypair) {}
+
+	async signTransaction(tx: Transaction): Promise<Transaction> {
+		tx.partialSign(this.payer);
+		return tx;
+	}
+
+	async signVersionedTransaction(
+		tx: VersionedTransaction
+	): Promise<VersionedTransaction> {
+		tx.sign([this.payer]);
+		return tx;
+	}
+
+	async signAllTransactions(txs: Transaction[]): Promise<Transaction[]> {
+		return txs.map((t) => {
+			t.partialSign(this.payer);
+			return t;
+		});
+	}
+
+	async signAllVersionedTransactions(
+		txs: VersionedTransaction[]
+	): Promise<VersionedTransaction[]> {
+		return txs.map((t) => {
+			t.sign([this.payer]);
+			return t;
+		});
+	}
+
+	get publicKey(): PublicKey {
+		return this.payer.publicKey;
+	}
+}
+
+export class WalletV2 extends Wallet {
+	constructor(readonly payer: Keypair) {
+		super(payer);
+	}
+
+	async signMessage(message: Uint8Array): Promise<Uint8Array> {
+		return Buffer.from(nacl.sign.detached(message, this.payer.secretKey));
+	}
+}

package/tests/DriftCore/decode.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from 'bun:test';
+import { VelocityCore } from '../../src/core/VelocityCore';
+import { userAccountBufferStrings } from '../decode/userAccountBufferStrings';
+
+describe('DriftCore decoding', () => {
+	test('can decode User account from fixture buffer', () => {
+		const s = userAccountBufferStrings[0];
+		const buf = Buffer.from(s, 'base64');
+		const decoded = VelocityCore.decodeUserAccount(buf);
+
+		expect(decoded).toBeTruthy();
+		expect(decoded.authority).toBeTruthy();
+		expect(decoded.delegate).toBeTruthy();
+		expect(decoded.name).toBeTruthy();
+	});
+});

package/tests/DriftCore/fill_trigger.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { VelocityCore } from '../../src/core/VelocityCore';
+
+describe('DriftCore fill/trigger builders', () => {
+	test('buildFillPerpOrderInstruction wires accounts + args', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+
+		const program = {
+			instruction: {
+				fillPerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await VelocityCore.buildFillPerpOrderInstruction({
+			program,
+			orderId: 7,
+			state: pk(),
+			filler: pk(),
+			fillerStats: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+
+		expect(ix).toBe(fakeIx as any);
+		expect(called.length).toBe(1);
+		expect(called[0][0]).toBe(7);
+	});
+
+	test('buildTriggerOrderInstruction wires accounts + args', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+
+		const program = {
+			instruction: {
+				triggerOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await VelocityCore.buildTriggerOrderInstruction({
+			program,
+			orderId: 9,
+			state: pk(),
+			filler: pk(),
+			user: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+
+		expect(ix).toBe(fakeIx as any);
+		expect(called.length).toBe(1);
+		expect(called[0][0]).toBe(9);
+	});
+});

package/tests/DriftCore/instructions.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'bun:test';
+import { VelocityCore } from '../../src/core/VelocityCore';
+import { Keypair } from '@solana/web3.js';
+import { BN } from '../../src/isomorphic/anchor';
+
+describe('DriftCore instruction builders', () => {
+	test('buildDepositInstruction calls underlying program.deposit', async () => {
+		const called: any[] = [];
+		const fakeIx = {
+			keys: [],
+			programId: Keypair.generate().publicKey,
+			data: Buffer.alloc(0),
+		};
+
+		const program = {
+			instruction: {
+				deposit: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+
+		const pk = () => Keypair.generate().publicKey;
+
+		const ix = await VelocityCore.buildDepositInstruction({
+			program,
+			marketIndex: 1,
+			amount: new BN(123),
+			reduceOnly: false,
+			state: pk(),
+			spotMarket: pk(),
+			spotMarketVault: pk(),
+			user: pk(),
+			userStats: pk(),
+			userTokenAccount: pk(),
+			authority: pk(),
+			tokenProgram: pk(),
+			remainingAccounts: [],
+		});
+
+		expect(ix).toBe(fakeIx as any);
+		expect(called.length).toBe(1);
+		expect(called[0][0]).toBe(1);
+	});
+});

package/tests/DriftCore/pdas.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair, PublicKey } from '@solana/web3.js';
+import { VelocityCore } from '../../src/core/VelocityCore';
+
+describe('DriftCore.pdas', () => {
+	test('derives deterministic user/state PDAs', async () => {
+		const programId = Keypair.generate().publicKey;
+		const authority = Keypair.generate().publicKey;
+
+		const [state] =
+			await VelocityCore.pdas.getDriftStateAccountPublicKeyAndNonce(programId);
+		const user0 = await VelocityCore.pdas.getUserAccountPublicKey(
+			programId,
+			authority,
+			0
+		);
+		const user1 = await VelocityCore.pdas.getUserAccountPublicKey(
+			programId,
+			authority,
+			1
+		);
+
+		expect(state).toBeInstanceOf(PublicKey);
+		expect(user0).toBeInstanceOf(PublicKey);
+		expect(user1).toBeInstanceOf(PublicKey);
+		expect(user0.toBase58()).not.toEqual(user1.toBase58());
+	});
+});

package/tests/DriftCore/perp_orders.test.ts

@@ -0,0 +1,205 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { VelocityCore } from '../../src/core/VelocityCore';
+
+describe('VelocityCore perp order instruction builders', () => {
+	const pk = () => Keypair.generate().publicKey;
+	const fakeIx = {
+		keys: [],
+		programId: Keypair.generate().publicKey,
+		data: Buffer.alloc(0),
+	};
+
+	test('buildPlacePerpOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				placePerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await VelocityCore.buildPlacePerpOrderInstruction({
+			program,
+			orderParams: { x: 1 },
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toEqual({ x: 1 });
+	});
+
+	test('buildPlaceAndTakePerpOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				placeAndTakePerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await VelocityCore.buildPlaceAndTakePerpOrderInstruction({
+			program,
+			orderParams: { m: 0 },
+			optionalParams: 256,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][1]).toBe(256);
+	});
+
+	test('buildPlaceAndMakePerpOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				placeAndMakePerpOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await VelocityCore.buildPlaceAndMakePerpOrderInstruction({
+			program,
+			orderParams: {},
+			takerOrderId: 7,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			taker: pk(),
+			takerStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][1]).toBe(7);
+	});
+
+	test('buildCancelOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				cancelOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await VelocityCore.buildCancelOrderInstruction({
+			program,
+			orderId: 3,
+			state: pk(),
+			user: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(3);
+	});
+
+	test('buildCancelOrderByUserIdInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				cancelOrderByUserId: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ix = await VelocityCore.buildCancelOrderByUserIdInstruction({
+			program,
+			userOrderId: 9,
+			state: pk(),
+			user: pk(),
+			authority: pk(),
+			oracle: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(9);
+	});
+
+	test('buildCancelOrdersByIdsInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				cancelOrdersByIds: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const ids = [1, 2];
+		const ix = await VelocityCore.buildCancelOrdersByIdsInstruction({
+			program,
+			orderIds: ids,
+			state: pk(),
+			user: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(ids);
+	});
+
+	test('buildModifyOrderInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				modifyOrder: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const mp = { baseAssetAmount: null };
+		const ix = await VelocityCore.buildModifyOrderInstruction({
+			program,
+			orderId: 4,
+			modifyParams: mp,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(4);
+		expect(called[0][1]).toBe(mp);
+	});
+
+	test('buildModifyOrderByUserIdInstruction', async () => {
+		const called: any[] = [];
+		const program = {
+			instruction: {
+				modifyOrderByUserId: async (...args: any[]) => {
+					called.push(args);
+					return fakeIx;
+				},
+			},
+		};
+		const mp = { reduceOnly: false };
+		const ix = await VelocityCore.buildModifyOrderByUserIdInstruction({
+			program,
+			userOrderId: 11,
+			modifyParams: mp,
+			state: pk(),
+			user: pk(),
+			userStats: pk(),
+			authority: pk(),
+			remainingAccounts: [],
+		});
+		expect(ix).toBe(fakeIx as any);
+		expect(called[0][0]).toBe(11);
+		expect(called[0][1]).toBe(mp);
+	});
+});

package/tests/DriftCore/remainingAccounts.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from 'bun:test';
+import { Keypair } from '@solana/web3.js';
+import { VelocityCore } from '../../src/core/VelocityCore';
+import { BN } from '../../src/isomorphic/anchor';
+import type { UserAccount } from '../../src/types';
+
+describe('VelocityCore.remainingAccounts', () => {
+	test('includes spot/perp + oracle accounts based on user positions', () => {
+		const spotMarket0 = {
+			marketIndex: 0,
+			pubkey: Keypair.generate().publicKey,
+			oracle: Keypair.generate().publicKey,
+		} as any;
+		const quoteSpotMarket = {
+			marketIndex: 0,
+			pubkey: spotMarket0.pubkey,
+			oracle: spotMarket0.oracle,
+		} as any;
+		const perpMarket0 = {
+			pubkey: Keypair.generate().publicKey,
+			quoteSpotMarketIndex: 0,
+			amm: {
+				oracle: Keypair.generate().publicKey,
+				oracleSource: { prelaunch: {} },
+			},
+		} as any;
+
+		const user: UserAccount = {
+			authority: Keypair.generate().publicKey,
+			subAccountId: 0,
+			spotPositions: [
+				{
+					marketIndex: 0,
+					scaledBalance: new BN(1),
+					openBids: new BN(0),
+					openAsks: new BN(0),
+					cumulativeDeposits: new BN(0),
+					balanceType: { deposit: {} },
+					openOrders: 0,
+				} as any,
+			],
+			perpPositions: [
+				{
+					marketIndex: 0,
+					baseAssetAmount: new BN(1),
+				} as any,
+			],
+		} as any;
+
+		const ctx = {
+			getPerpMarketAccount: () => perpMarket0,
+			getSpotMarketAccount: () => quoteSpotMarket,
+			getUserAccountAndSlot: () => ({ slot: 0 }),
+			activeSubAccountId: 0,
+			authority: user.authority,
+			perpMarketLastSlotCache: new Map<number, number>(),
+			spotMarketLastSlotCache: new Map<number, number>(),
+			mustIncludePerpMarketIndexes: new Set<number>(),
+			mustIncludeSpotMarketIndexes: new Set<number>(),
+		};
+
+		const metas = VelocityCore.remainingAccounts.getRemainingAccounts(
+			ctx as any,
+			{
+				userAccounts: [user],
+			}
+		);
+
+		const keys = new Set(metas.map((m) => m.pubkey.toBase58()));
+		expect(keys.has(perpMarket0.pubkey.toBase58())).toBe(true);
+		expect(keys.has(perpMarket0.amm.oracle.toBase58())).toBe(true);
+	});
+});