@velocity-exchange/sdk 0.0.1

package/src/core/instructions/perpOrders.ts

@@ -0,0 +1,192 @@
+import type {
+	AccountMeta,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import type { VelocityProgram } from '../../config';
+
+export async function buildPlacePerpOrderInstruction(args: {
+	program: VelocityProgram;
+	orderParams: any;
+	state: PublicKey;
+	user: PublicKey;
+	userStats: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).placePerpOrder(
+		args.orderParams,
+		{
+			accounts: {
+				state: args.state,
+				user: args.user,
+				userStats: args.userStats,
+				authority: args.authority,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}
+
+export async function buildPlaceAndTakePerpOrderInstruction(args: {
+	program: VelocityProgram;
+	orderParams: any;
+	optionalParams: number | null;
+	state: PublicKey;
+	user: PublicKey;
+	userStats: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await args.program.instruction.placeAndTakePerpOrder(
+		args.orderParams,
+		args.optionalParams,
+		{
+			accounts: {
+				state: args.state,
+				user: args.user,
+				userStats: args.userStats,
+				authority: args.authority,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}
+
+export async function buildPlaceAndMakePerpOrderInstruction(args: {
+	program: VelocityProgram;
+	orderParams: any;
+	takerOrderId: number;
+	state: PublicKey;
+	user: PublicKey;
+	userStats: PublicKey;
+	taker: PublicKey;
+	takerStats: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await args.program.instruction.placeAndMakePerpOrder(
+		args.orderParams,
+		args.takerOrderId,
+		{
+			accounts: {
+				state: args.state,
+				user: args.user,
+				userStats: args.userStats,
+				taker: args.taker,
+				takerStats: args.takerStats,
+				authority: args.authority,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}
+
+export async function buildCancelOrderInstruction(args: {
+	program: VelocityProgram;
+	orderId: number | null;
+	state: PublicKey;
+	user: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await args.program.instruction.cancelOrder(args.orderId, {
+		accounts: {
+			state: args.state,
+			user: args.user,
+			authority: args.authority,
+		},
+		remainingAccounts: args.remainingAccounts,
+	});
+}
+
+export async function buildCancelOrderByUserIdInstruction(args: {
+	program: VelocityProgram;
+	userOrderId: number;
+	state: PublicKey;
+	user: PublicKey;
+	authority: PublicKey;
+	oracle: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).cancelOrderByUserId(
+		args.userOrderId,
+		{
+			accounts: {
+				state: args.state,
+				user: args.user,
+				authority: args.authority,
+				oracle: args.oracle,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}
+
+export async function buildCancelOrdersByIdsInstruction(args: {
+	program: VelocityProgram;
+	orderIds: number[] | undefined;
+	state: PublicKey;
+	user: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await args.program.instruction.cancelOrdersByIds(args.orderIds, {
+		accounts: {
+			state: args.state,
+			user: args.user,
+			authority: args.authority,
+		},
+		remainingAccounts: args.remainingAccounts,
+	});
+}
+
+export async function buildModifyOrderInstruction(args: {
+	program: VelocityProgram;
+	orderId: number;
+	modifyParams: any;
+	state: PublicKey;
+	user: PublicKey;
+	userStats: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).modifyOrder(
+		args.orderId,
+		args.modifyParams,
+		{
+			accounts: {
+				state: args.state,
+				user: args.user,
+				userStats: args.userStats,
+				authority: args.authority,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}
+
+export async function buildModifyOrderByUserIdInstruction(args: {
+	program: VelocityProgram;
+	userOrderId: number;
+	modifyParams: any;
+	state: PublicKey;
+	user: PublicKey;
+	userStats: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).modifyOrderByUserId(
+		args.userOrderId,
+		args.modifyParams,
+		{
+			accounts: {
+				state: args.state,
+				user: args.user,
+				userStats: args.userStats,
+				authority: args.authority,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}

package/src/core/instructions/settlement.ts

@@ -0,0 +1,26 @@
+import type {
+	AccountMeta,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import type { VelocityProgram } from '../../config';
+
+export async function buildSettlePnlInstruction(args: {
+	program: VelocityProgram;
+	marketIndex: number;
+	state: PublicKey;
+	authority: PublicKey;
+	user: PublicKey;
+	spotMarketVault: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).settlePnl(args.marketIndex, {
+		accounts: {
+			state: args.state,
+			authority: args.authority,
+			user: args.user,
+			spotMarketVault: args.spotMarketVault,
+		},
+		remainingAccounts: args.remainingAccounts,
+	});
+}

package/src/core/instructions/trigger.ts

@@ -0,0 +1,26 @@
+import type {
+	AccountMeta,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import type { VelocityProgram } from '../../config';
+
+export async function buildTriggerOrderInstruction(args: {
+	program: VelocityProgram;
+	orderId: number;
+	state: PublicKey;
+	filler: PublicKey;
+	user: PublicKey;
+	authority: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).triggerOrder(args.orderId, {
+		accounts: {
+			state: args.state,
+			filler: args.filler,
+			user: args.user,
+			authority: args.authority,
+		},
+		remainingAccounts: args.remainingAccounts,
+	});
+}

package/src/core/instructions/withdraw.ts

@@ -0,0 +1,44 @@
+import type {
+	AccountMeta,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+import type { BN } from '../../isomorphic/anchor';
+import type { VelocityProgram } from '../../config';
+
+export async function buildWithdrawInstruction(args: {
+	program: VelocityProgram;
+	marketIndex: number;
+	amount: BN;
+	reduceOnly: boolean;
+	state: PublicKey;
+	spotMarket: PublicKey;
+	spotMarketVault: PublicKey;
+	driftSigner: PublicKey;
+	user: PublicKey;
+	userStats: PublicKey;
+	userTokenAccount: PublicKey;
+	authority: PublicKey;
+	tokenProgram: PublicKey;
+	remainingAccounts: AccountMeta[];
+}): Promise<TransactionInstruction> {
+	return await (args.program.instruction as any).withdraw(
+		args.marketIndex,
+		args.amount,
+		args.reduceOnly,
+		{
+			accounts: {
+				state: args.state,
+				spotMarket: args.spotMarket,
+				spotMarketVault: args.spotMarketVault,
+				driftSigner: args.driftSigner,
+				user: args.user,
+				userStats: args.userStats,
+				userTokenAccount: args.userTokenAccount,
+				authority: args.authority,
+				tokenProgram: args.tokenProgram,
+			},
+			remainingAccounts: args.remainingAccounts,
+		}
+	);
+}

package/src/core/remainingAccounts.ts

@@ -0,0 +1,276 @@
+import { PublicKey, type AccountMeta } from '@solana/web3.js';
+import { isVariant } from '../types';
+import { QUOTE_SPOT_MARKET_INDEX, ZERO } from '../constants/numericConstants';
+import { isSpotPositionAvailable } from '../math/spotPosition';
+import { positionIsAvailable } from '../math/position';
+import type {
+	UserAccount,
+	SpotMarketAccount,
+	PerpMarketAccount,
+} from '../types';
+
+export type RemainingAccountParams = {
+	userAccounts: UserAccount[];
+	writablePerpMarketIndexes?: number[];
+	writableSpotMarketIndexes?: number[];
+	readablePerpMarketIndex?: number | number[];
+	readableSpotMarketIndexes?: number[];
+	useMarketLastSlotCache?: boolean;
+};
+
+export type RemainingAccountsContext = {
+	/** Used to resolve market accounts. */
+	getPerpMarketAccount: (marketIndex: number) => PerpMarketAccount;
+	getSpotMarketAccount: (marketIndex: number) => SpotMarketAccount;
+
+	/** Used to resolve user's last slot for cache invalidation. */
+	getUserAccountAndSlot: (
+		subAccountId: number,
+		authority: PublicKey
+	) => { slot: number } | undefined;
+
+	activeSubAccountId: number;
+	authority: PublicKey;
+
+	/** Mutable caches + forced-market sets (owned by caller). */
+	perpMarketLastSlotCache: Map<number, number>;
+	spotMarketLastSlotCache: Map<number, number>;
+	mustIncludePerpMarketIndexes: Set<number>;
+	mustIncludeSpotMarketIndexes: Set<number>;
+};
+
+export function getRemainingAccounts(
+	ctx: RemainingAccountsContext,
+	params: RemainingAccountParams
+): AccountMeta[] {
+	const { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap } =
+		getRemainingAccountMapsForUsers(ctx, params.userAccounts);
+
+	if (params.useMarketLastSlotCache) {
+		const lastUserSlot = ctx.getUserAccountAndSlot(
+			params.userAccounts.length > 0
+				? params.userAccounts[0].subAccountId
+				: ctx.activeSubAccountId,
+			params.userAccounts.length > 0
+				? params.userAccounts[0].authority
+				: ctx.authority
+		)?.slot;
+
+		for (const [marketIndex, slot] of ctx.perpMarketLastSlotCache.entries()) {
+			if (slot > lastUserSlot) {
+				addPerpMarketToRemainingAccountMaps(
+					ctx,
+					marketIndex,
+					false,
+					oracleAccountMap,
+					spotMarketAccountMap,
+					perpMarketAccountMap
+				);
+			} else {
+				ctx.perpMarketLastSlotCache.delete(marketIndex);
+			}
+		}
+
+		for (const [marketIndex, slot] of ctx.spotMarketLastSlotCache.entries()) {
+			if (slot > lastUserSlot) {
+				addSpotMarketToRemainingAccountMaps(
+					ctx,
+					marketIndex,
+					false,
+					oracleAccountMap,
+					spotMarketAccountMap
+				);
+			} else {
+				ctx.spotMarketLastSlotCache.delete(marketIndex);
+			}
+		}
+	}
+
+	if (params.readablePerpMarketIndex !== undefined) {
+		const readablePerpMarketIndexes = Array.isArray(
+			params.readablePerpMarketIndex
+		)
+			? params.readablePerpMarketIndex
+			: [params.readablePerpMarketIndex];
+		for (const marketIndex of readablePerpMarketIndexes) {
+			addPerpMarketToRemainingAccountMaps(
+				ctx,
+				marketIndex,
+				false,
+				oracleAccountMap,
+				spotMarketAccountMap,
+				perpMarketAccountMap
+			);
+		}
+	}
+
+	for (const perpMarketIndex of ctx.mustIncludePerpMarketIndexes.values()) {
+		addPerpMarketToRemainingAccountMaps(
+			ctx,
+			perpMarketIndex,
+			false,
+			oracleAccountMap,
+			spotMarketAccountMap,
+			perpMarketAccountMap
+		);
+	}
+
+	if (params.readableSpotMarketIndexes !== undefined) {
+		for (const readableSpotMarketIndex of params.readableSpotMarketIndexes) {
+			addSpotMarketToRemainingAccountMaps(
+				ctx,
+				readableSpotMarketIndex,
+				false,
+				oracleAccountMap,
+				spotMarketAccountMap
+			);
+		}
+	}
+
+	for (const spotMarketIndex of ctx.mustIncludeSpotMarketIndexes.values()) {
+		addSpotMarketToRemainingAccountMaps(
+			ctx,
+			spotMarketIndex,
+			false,
+			oracleAccountMap,
+			spotMarketAccountMap
+		);
+	}
+
+	if (params.writablePerpMarketIndexes !== undefined) {
+		for (const writablePerpMarketIndex of params.writablePerpMarketIndexes) {
+			addPerpMarketToRemainingAccountMaps(
+				ctx,
+				writablePerpMarketIndex,
+				true,
+				oracleAccountMap,
+				spotMarketAccountMap,
+				perpMarketAccountMap
+			);
+		}
+	}
+
+	if (params.writableSpotMarketIndexes !== undefined) {
+		for (const writableSpotMarketIndex of params.writableSpotMarketIndexes) {
+			addSpotMarketToRemainingAccountMaps(
+				ctx,
+				writableSpotMarketIndex,
+				true,
+				oracleAccountMap,
+				spotMarketAccountMap
+			);
+		}
+	}
+
+	return [
+		...oracleAccountMap.values(),
+		...spotMarketAccountMap.values(),
+		...perpMarketAccountMap.values(),
+	];
+}
+
+function addPerpMarketToRemainingAccountMaps(
+	ctx: RemainingAccountsContext,
+	marketIndex: number,
+	writable: boolean,
+	oracleAccountMap: Map<string, AccountMeta>,
+	spotMarketAccountMap: Map<number, AccountMeta>,
+	perpMarketAccountMap: Map<number, AccountMeta>
+): void {
+	const perpMarketAccount = ctx.getPerpMarketAccount(marketIndex);
+	perpMarketAccountMap.set(marketIndex, {
+		pubkey: perpMarketAccount.pubkey,
+		isSigner: false,
+		isWritable: writable,
+	});
+	const oracleWritable =
+		writable && isVariant(perpMarketAccount.amm.oracleSource, 'prelaunch');
+	oracleAccountMap.set(perpMarketAccount.amm.oracle.toString(), {
+		pubkey: perpMarketAccount.amm.oracle,
+		isSigner: false,
+		isWritable: oracleWritable,
+	});
+	addSpotMarketToRemainingAccountMaps(
+		ctx,
+		perpMarketAccount.quoteSpotMarketIndex,
+		false,
+		oracleAccountMap,
+		spotMarketAccountMap
+	);
+}
+
+function addSpotMarketToRemainingAccountMaps(
+	ctx: RemainingAccountsContext,
+	marketIndex: number,
+	writable: boolean,
+	oracleAccountMap: Map<string, AccountMeta>,
+	spotMarketAccountMap: Map<number, AccountMeta>
+): void {
+	const spotMarketAccount = ctx.getSpotMarketAccount(marketIndex);
+	spotMarketAccountMap.set(spotMarketAccount.marketIndex, {
+		pubkey: spotMarketAccount.pubkey,
+		isSigner: false,
+		isWritable: writable,
+	});
+	if (!spotMarketAccount.oracle.equals(PublicKey.default)) {
+		oracleAccountMap.set(spotMarketAccount.oracle.toString(), {
+			pubkey: spotMarketAccount.oracle,
+			isSigner: false,
+			isWritable: false,
+		});
+	}
+}
+
+function getRemainingAccountMapsForUsers(
+	ctx: RemainingAccountsContext,
+	userAccounts: UserAccount[]
+): {
+	oracleAccountMap: Map<string, AccountMeta>;
+	spotMarketAccountMap: Map<number, AccountMeta>;
+	perpMarketAccountMap: Map<number, AccountMeta>;
+} {
+	const oracleAccountMap = new Map<string, AccountMeta>();
+	const spotMarketAccountMap = new Map<number, AccountMeta>();
+	const perpMarketAccountMap = new Map<number, AccountMeta>();
+
+	for (const userAccount of userAccounts) {
+		for (const spotPosition of userAccount.spotPositions) {
+			if (!isSpotPositionAvailable(spotPosition)) {
+				addSpotMarketToRemainingAccountMaps(
+					ctx,
+					spotPosition.marketIndex,
+					false,
+					oracleAccountMap,
+					spotMarketAccountMap
+				);
+
+				if (
+					!spotPosition.openAsks.eq(ZERO) ||
+					!spotPosition.openBids.eq(ZERO)
+				) {
+					addSpotMarketToRemainingAccountMaps(
+						ctx,
+						QUOTE_SPOT_MARKET_INDEX,
+						false,
+						oracleAccountMap,
+						spotMarketAccountMap
+					);
+				}
+			}
+		}
+		for (const position of userAccount.perpPositions) {
+			if (!positionIsAvailable(position)) {
+				addPerpMarketToRemainingAccountMaps(
+					ctx,
+					position.marketIndex,
+					false,
+					oracleAccountMap,
+					spotMarketAccountMap,
+					perpMarketAccountMap
+				);
+			}
+		}
+	}
+
+	return { oracleAccountMap, spotMarketAccountMap, perpMarketAccountMap };
+}

package/src/core/signedMsg.ts

@@ -0,0 +1,71 @@
+import { sha256 } from '@noble/hashes/sha256';
+import type {
+	SignedMsgOrderParamsDelegateMessage,
+	SignedMsgOrderParamsMessage,
+} from '../types';
+
+export type AnchorTypesCoder = {
+	encode: (typeName: string, value: any) => Buffer;
+	decode: (typeName: string, buffer: Buffer) => any;
+};
+
+export function encodeSignedMsgOrderParamsMessage(args: {
+	coderTypes: AnchorTypesCoder;
+	orderParamsMessage:
+		| SignedMsgOrderParamsMessage
+		| SignedMsgOrderParamsDelegateMessage;
+	delegateSigner?: boolean;
+}): Buffer {
+	const { coderTypes, delegateSigner } = args;
+	const orderParamsMessage: any = { ...args.orderParamsMessage };
+
+	if (orderParamsMessage.maxMarginRatio === undefined) {
+		orderParamsMessage.maxMarginRatio = null;
+	}
+	if (orderParamsMessage.isolatedPositionDeposit === undefined) {
+		orderParamsMessage.isolatedPositionDeposit = null;
+	}
+
+	const anchorIxName = delegateSigner
+		? 'global' + ':' + 'SignedMsgOrderParamsDelegateMessage'
+		: 'global' + ':' + 'SignedMsgOrderParamsMessage';
+	const prefix = Buffer.from(sha256(anchorIxName).slice(0, 8));
+
+	const withBuilderDefaults = {
+		...orderParamsMessage,
+		builderIdx:
+			orderParamsMessage.builderIdx !== undefined
+				? orderParamsMessage.builderIdx
+				: null,
+		builderFeeTenthBps:
+			orderParamsMessage.builderFeeTenthBps !== undefined
+				? orderParamsMessage.builderFeeTenthBps
+				: null,
+	};
+
+	const body = delegateSigner
+		? coderTypes.encode(
+				'signedMsgOrderParamsDelegateMessage',
+				withBuilderDefaults as SignedMsgOrderParamsDelegateMessage
+		  )
+		: coderTypes.encode(
+				'signedMsgOrderParamsMessage',
+				withBuilderDefaults as SignedMsgOrderParamsMessage
+		  );
+
+	return Buffer.concat([prefix, body]);
+}
+
+export function decodeSignedMsgOrderParamsMessage(args: {
+	coderTypes: AnchorTypesCoder;
+	encodedMessage: Buffer;
+	delegateSigner?: boolean;
+}): SignedMsgOrderParamsMessage | SignedMsgOrderParamsDelegateMessage {
+	const decodeStr = args.delegateSigner
+		? 'signedMsgOrderParamsDelegateMessage'
+		: 'signedMsgOrderParamsMessage';
+	return args.coderTypes.decode(
+		decodeStr,
+		Buffer.concat([args.encodedMessage.slice(8), Buffer.alloc(128)])
+	);
+}