Orders

import { BN, BASE_PRECISION, MarketType, PositionDirection, getMarketOrderParams } from "@velocity-exchange/sdk";
 
const orderParams = getMarketOrderParams({
  marketIndex: 0,
  marketType: MarketType.PERP,
  direction: PositionDirection.LONG,
  baseAssetAmount: new BN(1).mul(BASE_PRECISION), // 1 SOL (in 1e9 precision)
});

import { getOrderParams, OrderType, PositionDirection } from "@velocity-exchange/sdk";
 
const orderParams = getOrderParams({
  orderType: OrderType.LIMIT,
  marketIndex: 0,
  direction: PositionDirection.LONG,
  baseAssetAmount: velocityClient.convertToPerpPrecision(1),   // 1 base unit → BN(1e9)
  price: velocityClient.convertToPricePrecision(21.23),         // $21.23 → BN(21_230_000)
});

// Assumes `velocityClient` is subscribed.
const txSig = await velocityClient.placePerpOrder(
  getMarketOrderParams({
    marketIndex: 0,
    direction: PositionDirection.LONG,
    baseAssetAmount: new BN(1).mul(BASE_PRECISION),
  })
);
console.log(txSig);

await velocityClient.placeOrders([
  {
    orderType: OrderType.LIMIT,
    marketType: MarketType.PERP,
    marketIndex: 0,
    direction: PositionDirection.LONG,
    baseAssetAmount: velocityClient.convertToPerpPrecision(1),
    price: velocityClient.convertToPricePrecision(21.23),
  },
  {
    orderType: OrderType.LIMIT,
    marketType: MarketType.PERP,
    marketIndex: 0,
    direction: PositionDirection.SHORT,
    baseAssetAmount: velocityClient.convertToPerpPrecision(1),
    oraclePriceOffset: velocityClient.convertToPricePrecision(0.05), // BN, not .toNumber()
  },
]);

import { BN, OrderType, PositionDirection, PRICE_PRECISION } from "@velocity-exchange/sdk";
 
const marketIndex = 18;
 
// Offsets are relative to oracle price (in PRICE_PRECISION)
// For a long: auction starts at a better (lower) price and ends at a worse (higher) price
const auctionStartPrice = PRICE_PRECISION.muln(-5).divn(10); // -$0.50 below oracle
const auctionEndPrice = PRICE_PRECISION.muln(5).divn(10);    // +$0.50 above oracle
 
const orderParams = {
  orderType: OrderType.ORACLE,
  baseAssetAmount: velocityClient.convertToPerpPrecision(10),
  direction: PositionDirection.LONG,
  marketIndex,
  auctionStartPrice,
  auctionEndPrice,
  oraclePriceOffset: velocityClient.convertToPricePrecision(0.30), // +$0.30 from oracle, BN
  auctionDuration: 30, // slots
};
 
await velocityClient.placePerpOrder(orderParams);

import { OrderType, PositionDirection } from "@velocity-exchange/sdk";
 
const orderParams = {
  orderType: OrderType.LIMIT,
  marketIndex: 0,
  direction: PositionDirection.LONG,
  baseAssetAmount: velocityClient.convertToPerpPrecision(1),
  price: velocityClient.convertToPricePrecision(21.23),
  builderIdx: 0,              // index into this user's approved-builders list
  builderFeeTenthBps: 100,    // 0.01% builder fee
};
 
await velocityClient.placePerpOrder(orderParams);

await velocityClient.cancelOrder(1);

await velocityClient.cancelOrdersByIds([1, 2, 3]);

import { MarketType, PositionDirection } from "@velocity-exchange/sdk";
 
// Cancel all long perp orders on market 0
await velocityClient.cancelOrders(MarketType.PERP, 0, PositionDirection.LONG);
 
// Cancel all orders across all markets
await velocityClient.cancelOrders(null, null, null);

await velocityClient.cancelAndPlaceOrders(
  { marketType: MarketType.PERP, marketIndex: 0 },
  [
    {
      orderType: OrderType.LIMIT,
      marketIndex: 0,
      direction: PositionDirection.LONG,
      baseAssetAmount: velocityClient.convertToPerpPrecision(1),
      price: velocityClient.convertToPricePrecision(21.23),
    },
  ]
);

await velocityClient.modifyOrder({
  orderId: 1,
  newBaseAmount: velocityClient.convertToPerpPrecision(2),
});

await velocityClient.modifyOrderByUserOrderId({
  userOrderId: 1,
  newBaseAmount: velocityClient.convertToPerpPrecision(2),
});

import { OrderTriggerCondition, OrderType, PositionDirection } from "@velocity-exchange/sdk";
 
const orderParams = {
  orderType: OrderType.TRIGGER_MARKET,
  marketIndex: 0,
  direction: PositionDirection.SHORT,
  baseAssetAmount: velocityClient.convertToPerpPrecision(1),
  triggerPrice: velocityClient.convertToPricePrecision(95),
  triggerCondition: OrderTriggerCondition.BELOW,
};
 
await velocityClient.placePerpOrder(orderParams);

import { ComputeBudgetProgram } from "@solana/web3.js";
import {
  MarketType, PositionDirection, OrderType, getOrderParams,
} from "@velocity-exchange/sdk";
 
// 1. Build individual instructions
const cancelIx = await velocityClient.getCancelOrdersIx(
  MarketType.PERP, // marketType (null to cancel all types)
  0,               // marketIndex (null to cancel across all markets)
  null             // direction (null to cancel both sides)
);
 
const placeIx = await velocityClient.getPlacePerpOrderIx(
  getOrderParams({
    orderType: OrderType.LIMIT,
    marketIndex: 0,
    direction: PositionDirection.LONG,
    baseAssetAmount: velocityClient.convertToPerpPrecision(1),
    price: velocityClient.convertToPricePrecision(21.0),
  })
);
 
// 2. Add compute budget instructions for priority fees
const computeUnitPrice = ComputeBudgetProgram.setComputeUnitPrice({
  microLamports: 50_000, // priority fee in micro-lamports per CU
});
const computeUnitLimit = ComputeBudgetProgram.setComputeUnitLimit({
  units: 400_000, // max compute units for the transaction
});
 
// 3. Build a versioned transaction with all instructions
const tx = await velocityClient.txSender.getVersionedTransaction(
  [computeUnitLimit, computeUnitPrice, cancelIx, placeIx],
  [],                       // lookup table accounts (AddressLookupTableAccount[])
  velocityClient.wallet.publicKey
);
 
// 4. Send the transaction
const { txSig } = await velocityClient.txSender.sendVersionedTransaction(
  tx,
  [],
  velocityClient.opts
);
console.log("Batch tx:", txSig);

// Params:
//   orderParams: OptionalOrderParams - same params as placePerpOrder()
//   subAccountId?: number - defaults to active subaccount
const ix = await velocityClient.getPlacePerpOrderIx(
  getOrderParams({
    orderType: OrderType.LIMIT,
    marketIndex: 0,
    direction: PositionDirection.LONG,
    baseAssetAmount: velocityClient.convertToPerpPrecision(1),
    price: velocityClient.convertToPricePrecision(21.0),
  })
);

import { MarketType, PositionDirection } from "@velocity-exchange/sdk";
 
// Params:
//   marketType: MarketType | null - filter by PERP or SPOT (null = all)
//   marketIndex: number | null - filter by market index (null = all)
//   direction: PositionDirection | null - filter by LONG or SHORT (null = both)
//   subAccountId?: number - defaults to active subaccount
 
// Cancel all perp orders on market 0
const ix = await velocityClient.getCancelOrdersIx(MarketType.PERP, 0, null);
 
// Cancel ALL orders across all markets
const ixAll = await velocityClient.getCancelOrdersIx(null, null, null);

// Params:
//   userAccountPublicKey: PublicKey - the taker's user account address
//   userAccount: UserAccount - the taker's deserialized user account
//   order: { marketIndex, orderId } - the order to fill
//   makerInfo?: MakerInfo | MakerInfo[] - optional maker(s) to match against
//   fillerSubAccountId?: number - filler's subaccount
//   isSignedMsg?: boolean
//   fillerAuthority?: PublicKey
//   hasBuilderFee?: boolean
//   takerEscrow?: RevenueShareEscrowAccount - the taker's decoded RevenueShareEscrow
//     (e.g. from a RevenueShareEscrowMap); REQUIRED when the taker's order carries a
//     builder code, or the taker's UserStats.referrerStatus has the BuilderReferral
//     bit — otherwise the program rejects the fill with UnableToLoadRevenueShareAccount.
 
const takerPubkey = takerUser.userAccountPublicKey;
const takerAccount = takerUser.getUserAccount();
const order = takerAccount.orders[0]; // the order to fill
 
const ix = await velocityClient.getFillPerpOrderIx(
  takerPubkey,
  takerAccount,
  { marketIndex: order.marketIndex, orderId: order.orderId }
);

// Params:
//   userAccountPublicKey: PublicKey - the user whose order to trigger
//   userAccount: UserAccount - the deserialized user account
//   order: Order - the full order object (must have trigger condition met)
//   fillerPublicKey?: PublicKey - optional, defaults to your user account
 
const userPubkey = targetUser.userAccountPublicKey;
const userAccount = targetUser.getUserAccount();
const triggerOrder = userAccount.orders.find(
  (o) => o.orderType.triggerMarket !== undefined || o.orderType.triggerLimit !== undefined
);
 
const ix = await velocityClient.getTriggerOrderIx(
  userPubkey,
  userAccount,
  triggerOrder
);

// Params:
//   fillerPublicKey?: PublicKey - defaults to your user account
const ix = await velocityClient.getRevertFillIx();

// Params:
//   users: Array of { settleeUserAccountPublicKey, settleeUserAccount }
//   marketIndexes: number[] - perp market indexes to settle
 
const user = velocityClient.getUser();
const ixs = await velocityClient.getSettlePNLsIxs(
  [
    {
      settleeUserAccountPublicKey: user.userAccountPublicKey,
      settleeUserAccount: user.getUserAccount(),
    },
  ],
  [0, 1] // settle PnL on perp markets 0 and 1
);
// ixs is an array of TransactionInstruction, one per user per market

// Params:
//   inMarketIndex: number - spot market index of the input token
//   outMarketIndex: number - spot market index of the output token
//   amount: BN - amount of input token (in spot precision)
//   slippageBps: number - max slippage in basis points
 
const ix = await velocityClient.getJupiterSwapIxV6({
  inMarketIndex: 0,   // e.g. quote asset
  outMarketIndex: 1,  // e.g. SOL
  amount: velocityClient.convertToSpotPrecision(0, 10), // 10 units of the quote asset
  slippageBps: 50,    // 0.5% max slippage
});