Orders

import { MarketType, PositionDirection, getMarketOrderParams } from "@velocity-exchange/sdk";

const orderParams = getMarketOrderParams({
  marketIndex: 0,
  marketType: MarketType.PERP,
  direction: PositionDirection.LONG,
  baseAssetAmount: velocityClient.convertToPerpPrecision(1), // 1 SOL, BN at 1e9
});

import { OrderType, PositionDirection, getOrderParams } 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)
});

import { PositionDirection, getMarketOrderParams } from "@velocity-exchange/sdk";

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

import { MarketType, OrderType, PositionDirection } from "@velocity-exchange/sdk";

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 {
  MarketType,
  PositionDirection,
  PostOnlyParams,
  SizeDistribution,
} from "@velocity-exchange/sdk";

// 10 SOL of bids laddered from $150 down to $140, in 5 orders,
// with the largest order at the top of the range.
await velocityClient.placeScaleOrders({
  marketType: MarketType.PERP,
  direction: PositionDirection.LONG,
  marketIndex: 0,
  totalBaseAssetAmount: velocityClient.convertToPerpPrecision(10),
  startPrice: velocityClient.convertToPricePrecision(150),
  endPrice: velocityClient.convertToPricePrecision(140),
  orderCount: 5,
  sizeDistribution: SizeDistribution.DESCENDING,
  reduceOnly: false,
  postOnly: PostOnlyParams.MUST_POST_ONLY,
  bitFlags: 0,
  maxTs: null,
});

import { OrderType, PRICE_PRECISION, PositionDirection } 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, // 400ms wall-clock units, 12s
};

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, // 10 bps, 0.1% of notional
};

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();

import { MarketType, OrderType, PositionDirection } from "@velocity-exchange/sdk";

await velocityClient.cancelAndPlaceOrders(
  { marketType: MarketType.PERP, marketIndex: 0 },
  [
    {
      orderType: OrderType.LIMIT,
      marketType: MarketType.PERP,
      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,
  OrderType,
  PositionDirection,
  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[])
);

// 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, otherwise the program rejects the fill with UnableToLoadRevenueShareAccount.
//   takerIsReferred?: boolean - set when the taker is referred (their UserStats.referrerStatus
//     has the BuilderReferral bit). This is the preferred way to satisfy the referred-taker
//     gate: it needs no account fetch. Passing a decoded takerEscrow for this case still
//     works, but is not required.

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 the caller's 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 the caller's 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

import { BN } from "@velocity-exchange/sdk";

// Params:
//   swapProvider: SwapProvider - a UnifiedSwapClient, TitanClient, or JupiterClient
//   inMarketIndex: number - spot market index of the input token
//   outMarketIndex: number - spot market index of the output token
//   amount: BN - amount of the input token, in the token's own mint decimals
//     (not a fixed protocol precision)
//   slippageBps: number - max slippage in basis points
//   swapMode?: SwapMode - ExactIn (default) or ExactOut
//   reduceOnly?: SwapReduceOnly - require the position to reduce, not flip sign

const { ixs, lookupTables } = await velocityClient.getProviderSwapIx({
  swapProvider,
  inMarketIndex: 0,   // e.g. quote asset
  outMarketIndex: 1,  // e.g. SOL
  amount: new BN(10_000_000), // amount in the input token's own mint decimals
  slippageBps: 50,    // 0.5% max slippage
});