@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/core/instructions/deposit.ts

@@ -1,64 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { BN } from '../../isomorphic/anchor';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `deposit` instruction, transferring tokens from `userTokenAccount` into the
- * protocol's `spotMarketVault` and crediting `user`'s spot position. Any signer may fund
- * someone else's `user` account (`authority` need not own/delegate for `user`) as long as
- * `userTokenAccount` is owned by `authority`; on mainnet, a non-owner/non-delegate
- * `authority` must additionally be on the on-chain external-depositor whitelist or the
- * instruction throws.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.marketIndex - target spot market index.
- * @param args.amount - deposit amount, in the spot market's mint's native token precision (e.g. 1e6 for a 6-decimal mint) — not a fixed SDK precision.
- * @param args.reduceOnly - if true (or the market is reduce-only), caps the deposit to the user's current borrow balance so it can only repay a borrow.
- * @param args.state - the global `State` PDA.
- * @param args.spotMarket - the target `SpotMarket` PDA.
- * @param args.spotMarketVault - the spot market's token vault PDA (transfer destination).
- * @param args.user - the `User` account being credited.
- * @param args.userStats - the depositing user's `UserStats` PDA.
- * @param args.userTokenAccount - source token account; must share a mint with `spotMarketVault` and be owned by `authority`.
- * @param args.authority - signer authorizing the token transfer.
- * @param args.tokenProgram - the SPL Token or Token-2022 program owning the mint.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` for `marketIndex`, plus the deposited mint account, plus any Token-2022 transfer-hook accounts.
- * @returns the unsigned `deposit` `TransactionInstruction`.
- */
-export async function buildDepositInstruction(args: {
-	program: VelocityProgram;
-	marketIndex: number;
-	amount: BN;
-	reduceOnly: boolean;
-	state: PublicKey;
-	spotMarket: PublicKey;
-	spotMarketVault: PublicKey;
-	user: PublicKey;
-	userStats: PublicKey;
-	userTokenAccount: PublicKey;
-	authority: PublicKey;
-	tokenProgram: PublicKey;
-	remainingAccounts: AccountMeta[];
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).deposit(
-		args.marketIndex,
-		args.amount,
-		args.reduceOnly,
-		{
-			accounts: {
-				state: args.state,
-				spotMarket: args.spotMarket,
-				spotMarketVault: args.spotMarketVault,
-				user: args.user,
-				userStats: args.userStats,
-				userTokenAccount: args.userTokenAccount,
-				authority: args.authority,
-				tokenProgram: args.tokenProgram,
-			},
-			remainingAccounts: args.remainingAccounts,
-		}
-	);
-}

package/src/core/instructions/fill.ts

@@ -1,51 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `fillPerpOrder` instruction, matching a resting perp order against the AMM
- * and/or the supplied maker accounts. Permissionless: `user` (the order owner) does not
- * need to sign — only `authority` (owner/delegate of `filler`) does. Hardcodes the
- * on-chain `makerOrderId` arg to `null` (no specific maker order is targeted; the
- * program matches from whichever maker/referrer accounts are supplied).
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderId - the order to fill, or `null` to fill `user`'s most recently placed order (resolved on-chain via `get_last_order_id`).
- * @param args.state - the global `State` PDA.
- * @param args.filler - the keeper's `User` account that earns the filler reward.
- * @param args.fillerStats - the filler's `UserStats` PDA.
- * @param args.user - the order owner's `User` account (the taker being filled).
- * @param args.userStats - the taker's `UserStats` PDA.
- * @param args.authority - signer that must own or be a registered delegate of `filler`.
- * @param args.remainingAccounts - writable perp market + oracle `AccountMeta[]` for the order's market, followed by any maker/referrer `(User, UserStats)` account pairs, followed by the taker's `RevenueShareEscrow` account if builder codes are enabled protocol-wide.
- * @returns the unsigned `fillPerpOrder` `TransactionInstruction`.
- */
-export async function buildFillPerpOrderInstruction(args: {
-	program: VelocityProgram;
-	orderId: number | null;
-	state: PublicKey;
-	filler: PublicKey;
-	fillerStats: PublicKey;
-	user: PublicKey;
-	userStats: PublicKey;
-	authority: PublicKey;
-	remainingAccounts: AccountMeta[];
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).fillPerpOrder(
-		args.orderId,
-		null,
-		{
-			accounts: {
-				state: args.state,
-				filler: args.filler,
-				fillerStats: args.fillerStats,
-				user: args.user,
-				userStats: args.userStats,
-				authority: args.authority,
-			},
-			remainingAccounts: args.remainingAccounts,
-		}
-	);
-}

package/src/core/instructions/funding.ts

@@ -1,33 +0,0 @@
-import type { PublicKey, TransactionInstruction } from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds an `updateFundingRate` instruction. Fully permissionless keeper crank — no
- * signer is required at all; anyone can submit this to advance a perp market's funding
- * rate once its funding period has elapsed. Throws `FundingWasNotUpdated` on-chain if
- * called before the market's funding period has elapsed.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.perpMarketIndex - the perp market to update.
- * @param args.state - the global `State` PDA.
- * @param args.perpMarket - the target `PerpMarket` PDA.
- * @param args.oracle - the perp market's oracle account (must match `perpMarket.amm.oracle`).
- * @returns the unsigned `updateFundingRate` `TransactionInstruction`.
- */
-export async function buildUpdateFundingRateInstruction(args: {
-	program: VelocityProgram;
-	perpMarketIndex: number;
-	state: PublicKey;
-	perpMarket: PublicKey;
-	oracle: PublicKey;
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).updateFundingRate(
-		args.perpMarketIndex,
-		{
-			accounts: {
-				state: args.state,
-				perpMarket: args.perpMarket,
-				oracle: args.oracle,
-			},
-		}
-	);
-}

package/src/core/instructions/liquidation.ts

@@ -1,55 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `liquidatePerp` instruction, letting `liquidator` take over (part of) an
- * under-margined perp position from `user`. `user` does not need to sign; `authority`
- * must own or be a delegate of `liquidator`, and `liquidator` must differ from `user`
- * (self-liquidation throws `UserCantLiquidateThemself`).
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.marketIndex - the perp market being liquidated.
- * @param args.maxBaseAssetAmount - maximum base amount the liquidator is willing to take on, BASE_PRECISION (1e9).
- * @param args.limitPrice - worst acceptable execution price, PRICE_PRECISION (1e6), or `null` for no limit.
- * @param args.state - the global `State` PDA.
- * @param args.authority - signer that must own or be a registered delegate of `liquidator`.
- * @param args.user - the `User` account being liquidated.
- * @param args.userStats - the liquidated user's `UserStats` PDA.
- * @param args.liquidator - the `User` account taking over the position; must not equal `user`.
- * @param args.liquidatorStats - the liquidator's `UserStats` PDA.
- * @param args.remainingAccounts - writable perp market + oracle `AccountMeta[]` for `marketIndex`.
- * @returns the unsigned `liquidatePerp` `TransactionInstruction`.
- */
-export async function buildLiquidatePerpInstruction(args: {
-	program: VelocityProgram;
-	marketIndex: number;
-	maxBaseAssetAmount: any;
-	limitPrice: any | null;
-	state: PublicKey;
-	authority: PublicKey;
-	user: PublicKey;
-	userStats: PublicKey;
-	liquidator: PublicKey;
-	liquidatorStats: PublicKey;
-	remainingAccounts: AccountMeta[];
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).liquidatePerp(
-		args.marketIndex,
-		args.maxBaseAssetAmount,
-		args.limitPrice,
-		{
-			accounts: {
-				state: args.state,
-				authority: args.authority,
-				user: args.user,
-				userStats: args.userStats,
-				liquidator: args.liquidator,
-				liquidatorStats: args.liquidatorStats,
-			},
-			remainingAccounts: args.remainingAccounts,
-		}
-	);
-}

package/src/core/instructions/orders.ts

@@ -1,84 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `placeOrders` instruction, placing a batch of up to 32 perp and/or spot
- * orders in one instruction. None of the orders may be immediate-or-cancel — IOC orders
- * are only valid via `placeAndTake`/`placeAndMake` — or the instruction throws.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.formattedParams - array of `OrderParams`: `baseAssetAmount` is BASE_PRECISION (1e9), `price`/`triggerPrice`/`oraclePriceOffset` are PRICE_PRECISION (1e6).
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account the orders are placed on; `authority` must own or be a delegate of it.
- * @param args.userStats - accepted for forward-compatibility but not required by the current on-chain `place_orders` accounts (only `state`/`user`/`authority` are used).
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` covering every order's market, plus the placing user's `RevenueShareEscrow` account when any order carries a `builderIdx` and builder codes are enabled protocol-wide.
- * @returns the unsigned `placeOrders` `TransactionInstruction`.
- */
-export async function buildPlaceOrdersInstruction(args: {
-	program: VelocityProgram;
-	formattedParams: any[];
-	state: PublicKey;
-	user: PublicKey;
-	userStats: PublicKey;
-	authority: PublicKey;
-	remainingAccounts: AccountMeta[];
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).placeOrders(
-		args.formattedParams,
-		{
-			accounts: {
-				state: args.state,
-				user: args.user,
-				userStats: args.userStats,
-				authority: args.authority,
-			},
-			remainingAccounts: args.remainingAccounts,
-		}
-	);
-}
-
-/**
- * Builds a `cancelOrders` instruction, cancelling every open order on `user` that
- * matches all of the given (optional) filters. `null`/`undefined` on a filter means
- * "don't filter on this dimension" — leaving all three `null` cancels every open order.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.marketType - only cancel orders of this `MarketType` (`Perp`/`Spot`), or `null` for both.
- * @param args.marketIndex - only cancel orders on this market index, or `null` for all markets.
- * @param args.direction - only cancel orders with this `PositionDirection`, or `null` for both.
- * @param args.user - the `User` account whose orders are cancelled.
- * @param args.state - the global `State` PDA.
- * @param args.userStats - accepted for forward-compatibility but not required by the current on-chain `cancel_orders` accounts (only `state`/`user`/`authority` are used).
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` needed to re-derive auction/oracle-offset prices for the cancelled orders.
- * @returns the unsigned `cancelOrders` `TransactionInstruction`.
- */
-export async function buildCancelOrdersInstruction(args: {
-	program: VelocityProgram;
-	marketType: any;
-	marketIndex: number | null;
-	direction: any;
-	user: PublicKey;
-	state: PublicKey;
-	userStats: PublicKey;
-	authority: PublicKey;
-	remainingAccounts: AccountMeta[];
-}): Promise<TransactionInstruction> {
-	return await (args.program.instruction as any).cancelOrders(
-		args.marketType,
-		args.marketIndex,
-		args.direction,
-		{
-			accounts: {
-				state: args.state,
-				user: args.user,
-				userStats: args.userStats,
-				authority: args.authority,
-			},
-			remainingAccounts: args.remainingAccounts,
-		}
-	);
-}

package/src/core/instructions/perpOrders.ts

@@ -1,312 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `placePerpOrder` instruction, placing a single resting perp order. Rejects
- * immediate-or-cancel orders (`InvalidOrderIOC`) — use `buildPlaceAndTakePerpOrderInstruction`
- * or `buildPlaceAndMakePerpOrderInstruction` for IOC orders instead.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderParams - an `OrderParams` object; `baseAssetAmount` is BASE_PRECISION (1e9), `price`/`triggerPrice`/`oraclePriceOffset` are PRICE_PRECISION (1e6).
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account the order is placed on.
- * @param args.userStats - accepted for forward-compatibility but not required by the current on-chain `place_perp_order` accounts.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` for `orderParams.marketIndex`, plus the placing user's `RevenueShareEscrow` account if the order carries a `builderIdx` and builder codes are enabled protocol-wide.
- * @returns the unsigned `placePerpOrder` `TransactionInstruction`.
- */
-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,
-		}
-	);
-}
-
-/**
- * Builds a `placeAndTakePerpOrder` instruction: places an order and immediately attempts
- * to fill it as a taker against the AMM and/or the supplied maker accounts.
- * `orderParams.postOnly` must be `PostOnlyParam.None` (`InvalidOrderPostOnly` otherwise).
- * Any portion left unfilled is auto-cancelled when the order is (or becomes, via
- * `optionalParams`) immediate-or-cancel.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderParams - an `OrderParams` object; `baseAssetAmount` is BASE_PRECISION (1e9), `price`/`triggerPrice`/`oraclePriceOffset` are PRICE_PRECISION (1e6).
- * @param args.optionalParams - packed `u32` combining a `PlaceAndTakeOrderSuccessCondition` (fail the tx if not at least partially/fully filled) and an auction-duration percentage override; `null` for default behavior. Passing any non-null value also forces IOC cancel-remainder semantics.
- * @param args.state - the global `State` PDA.
- * @param args.user - the taker's `User` account.
- * @param args.userStats - the taker's `UserStats` PDA.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - writable perp market + oracle `AccountMeta[]` for `orderParams.marketIndex`, followed by maker/referrer `(User, UserStats)` pairs, followed by the taker's `RevenueShareEscrow` account if builder codes are enabled.
- * @returns the unsigned `placeAndTakePerpOrder` `TransactionInstruction`.
- */
-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,
-		}
-	);
-}
-
-/**
- * Builds a `placeAndMakePerpOrder` instruction: posts an immediate-or-cancel, post-only
- * `Limit` order for `user` and immediately fills it as the maker against `taker`'s
- * existing resting order (`InvalidOrderIOCPostOnly` if `orderParams` isn't IOC + post-only
- * + `Limit`). Any unfilled remainder of the just-placed maker order is auto-cancelled.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderParams - an `OrderParams` object; `baseAssetAmount` is BASE_PRECISION (1e9), `price`/`oraclePriceOffset` are PRICE_PRECISION (1e6).
- * @param args.takerOrderId - the on-chain order ID of `taker`'s resting order being filled.
- * @param args.state - the global `State` PDA.
- * @param args.user - the maker's `User` account.
- * @param args.userStats - the maker's `UserStats` PDA.
- * @param args.taker - the taker's `User` account (order owner being filled).
- * @param args.takerStats - the taker's `UserStats` PDA.
- * @param args.authority - signer that must own or be a registered delegate of `user` (the maker).
- * @param args.remainingAccounts - writable perp market + oracle `AccountMeta[]` for `orderParams.marketIndex`, followed by any additional maker/referrer `(User, UserStats)` pairs needed to fill `taker`'s order, followed by `taker`'s `RevenueShareEscrow` account if builder codes are enabled.
- * @returns the unsigned `placeAndMakePerpOrder` `TransactionInstruction`.
- */
-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,
-		}
-	);
-}
-
-/**
- * Build a raw `cancelOrder` instruction.
- *
- * Pass `orderId: null` to cancel the user's most recently placed order. The program
- * resolves a `null` ID on-chain via `get_last_order_id`, which makes this safe to use
- * in a multi-instruction transaction where a place instruction precedes the cancel and
- * the program-assigned order ID is not yet known at build time — e.g.:
- *
- *   [placePerpOrder] → [cancelOrder(orderId: null)]
- *
- * The on-chain `order_id` counter is a monotonically incrementing u32 on the user
- * account, so `get_last_order_id` reliably points to the order placed in the preceding
- * instruction of the same transaction.
- *
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderId - the order to cancel, or `null` per the above.
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account whose order is cancelled.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` needed to re-derive the cancelled order's auction/oracle-offset price.
- * @returns the unsigned `cancelOrder` `TransactionInstruction`.
- */
-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,
-	});
-}
-
-/**
- * Builds a `cancelOrderByUserId` instruction, cancelling the order matching the
- * caller-assigned `userOrderId` (the `OrderParams.userOrderId` tag set at placement)
- * rather than the program-assigned order ID.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.userOrderId - the caller-assigned order tag (`u8`) supplied when the order was placed.
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account whose order is cancelled.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.oracle - accepted for forward-compatibility but not required by the current on-chain `cancel_order_by_user_id` accounts (only `state`/`user`/`authority` are used).
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` needed to re-derive the cancelled order's auction/oracle-offset price.
- * @returns the unsigned `cancelOrderByUserId` `TransactionInstruction`.
- */
-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,
-		}
-	);
-}
-
-/**
- * Builds a `cancelOrdersByIds` instruction, cancelling multiple orders by their
- * program-assigned order IDs in one instruction (loops `cancel_order_by_order_id`
- * on-chain, one order at a time — an order ID that no longer exists is silently
- * skipped rather than failing the whole instruction).
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderIds - order IDs to cancel; passing `undefined` sends an empty list on-chain (cancels nothing).
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account whose orders are cancelled.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` needed to re-derive the cancelled orders' auction/oracle-offset prices.
- * @returns the unsigned `cancelOrdersByIds` `TransactionInstruction`.
- */
-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,
-	});
-}
-
-/**
- * Builds a `modifyOrder` instruction, mutating an existing resting order in place (e.g.
- * new price/size/trigger) rather than cancel-and-replace.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderId - the program-assigned order ID to modify (use `buildModifyOrderByUserIdInstruction` to target by the caller-assigned tag instead).
- * @param args.modifyParams - a `ModifyOrderParams` object; any `baseAssetAmount`/`price`/`triggerPrice` overrides use BASE_PRECISION (1e9) / PRICE_PRECISION (1e6) respectively.
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account whose order is modified.
- * @param args.userStats - accepted for forward-compatibility but not required by the current on-chain `modify_order` accounts.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
- * @returns the unsigned `modifyOrder` `TransactionInstruction`.
- */
-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,
-		}
-	);
-}
-
-/**
- * Builds a `modifyOrderByUserId` instruction, same as `buildModifyOrderInstruction` but
- * targeting the order by its caller-assigned `userOrderId` tag.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.userOrderId - the caller-assigned order tag (`u8`) supplied when the order was placed.
- * @param args.modifyParams - a `ModifyOrderParams` object; any `baseAssetAmount`/`price`/`triggerPrice` overrides use BASE_PRECISION (1e9) / PRICE_PRECISION (1e6) respectively.
- * @param args.state - the global `State` PDA.
- * @param args.user - the `User` account whose order is modified.
- * @param args.userStats - accepted for forward-compatibility but not required by the current on-chain `modify_order_by_user_id` accounts.
- * @param args.authority - signer that must own or be a registered delegate of `user`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
- * @returns the unsigned `modifyOrderByUserId` `TransactionInstruction`.
- */
-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

@@ -1,40 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `settlePnl` instruction, settling `user`'s realized (or, if the market is in
- * `Settlement` status, expired) perp PnL on `marketIndex` against the quote spot market
- * vault. Fully permissionless: `authority` does not need to own or be a delegate of
- * `user` — any signer can crank this.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.marketIndex - the perp market whose position PnL is settled.
- * @param args.state - the global `State` PDA.
- * @param args.authority - any signer; not required to own `user`.
- * @param args.user - the `User` account being settled.
- * @param args.spotMarketVault - the quote (market index 0) spot market's token vault PDA.
- * @param args.remainingAccounts - writable perp market + oracle `AccountMeta[]` for `marketIndex`, plus the writable quote spot market, plus (if builder codes are enabled) `user`'s `RevenueShareEscrow` and the revenue-share market map needed to sweep completed builder fees.
- * @returns the unsigned `settlePnl` `TransactionInstruction`.
- */
-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

@@ -1,41 +0,0 @@
-import type {
-	AccountMeta,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-import type { VelocityProgram } from '../../config';
-
-/**
- * Builds a `triggerOrder` instruction, flipping a resting trigger order (stop-loss /
- * take-profit) into a fillable order once its trigger condition is met against the
- * oracle price. Permissionless: `user` (the order owner) does not need to sign — only
- * `authority` (owner/delegate of `filler`) does. Does not fill the order itself; a
- * subsequent `fillPerpOrder` (or a `placeAndTake`) is needed to execute it.
- * @param args.program - Anchor `Program<Velocity>` used to build the instruction.
- * @param args.orderId - the trigger order's on-chain order ID.
- * @param args.state - the global `State` PDA.
- * @param args.filler - the keeper's `User` account submitting the trigger.
- * @param args.user - the order owner's `User` account.
- * @param args.authority - signer that must own or be a registered delegate of `filler`.
- * @param args.remainingAccounts - oracle/market `AccountMeta[]` for the order's market.
- * @returns the unsigned `triggerOrder` `TransactionInstruction`.
- */
-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,
-	});
-}