Orders

import { BN, BASE_PRECISION, MarketType, PositionDirection, getMarketOrderParams } from "@drift-labs/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 "@drift-labs/sdk";
 
const orderParams = getOrderParams({
  orderType: OrderType.LIMIT,
  marketIndex: 0,
  direction: PositionDirection.LONG,
  baseAssetAmount: driftClient.convertToPerpPrecision(1),   // 1 base unit → BN(1e9)
  price: driftClient.convertToPricePrecision(21.23),         // $21.23 → BN(21_230_000)
});

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

import { OrderType, PositionDirection } from "@drift-labs/sdk";
 
await driftClient.placeSpotOrder({
  orderType: OrderType.LIMIT,
  marketIndex: 1, // e.g. SOL spot
  direction: PositionDirection.LONG,
  baseAssetAmount: driftClient.convertToSpotPrecision(1, 1), // 1 SOL
  price: driftClient.convertToPricePrecision(150),
});

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

import { BN, OrderType, PositionDirection, PRICE_PRECISION } from "@drift-labs/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: driftClient.convertToPerpPrecision(10),
  direction: PositionDirection.LONG,
  marketIndex,
  auctionStartPrice,
  auctionEndPrice,
  oraclePriceOffset: driftClient.convertToPricePrecision(0.30).toNumber(), // +$0.30 from oracle
  auctionDuration: 30, // slots
};
 
await driftClient.placePerpOrder(orderParams);

await driftClient.cancelOrder(1);

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

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

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

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

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

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

import { ComputeBudgetProgram } from "@solana/web3.js";
import {
  MarketType, PositionDirection, OrderType, getOrderParams,
} from "@drift-labs/sdk";
 
// 1. Build individual instructions
const cancelIx = await driftClient.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 driftClient.getPlacePerpOrderIx(
  getOrderParams({
    orderType: OrderType.LIMIT,
    marketIndex: 0,
    direction: PositionDirection.LONG,
    baseAssetAmount: driftClient.convertToPerpPrecision(1),
    price: driftClient.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 driftClient.txSender.getVersionedTransaction(
  [computeUnitLimit, computeUnitPrice, cancelIx, placeIx],
  [],                       // lookup table accounts (AddressLookupTableAccount[])
  driftClient.wallet.publicKey
);
 
// 4. Send the transaction
const { txSig } = await driftClient.txSender.sendVersionedTransaction(
  tx,
  [],
  driftClient.opts
);
console.log("Batch tx:", txSig);

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

// Params:
//   orderParams: OptionalOrderParams - same params as placeSpotOrder()
//   subAccountId?: number - defaults to active subaccount
const ix = await driftClient.getPlaceSpotOrderIx({
  orderType: OrderType.LIMIT,
  marketIndex: 1,
  direction: PositionDirection.LONG,
  baseAssetAmount: driftClient.convertToSpotPrecision(1, 1),
  price: driftClient.convertToPricePrecision(150),
});

import { MarketType, PositionDirection } from "@drift-labs/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 driftClient.getCancelOrdersIx(MarketType.PERP, 0, null);
 
// Cancel ALL orders across all markets
const ixAll = await driftClient.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
//   referrerInfo?: ReferrerInfo - optional referrer for fee sharing
//   fillerSubAccountId?: number - filler's subaccount
 
const takerPubkey = takerUser.userAccountPublicKey;
const takerAccount = takerUser.getUserAccount();
const order = takerAccount.orders[0]; // the order to fill
 
const ix = await driftClient.getFillPerpOrderIx(
  takerPubkey,
  takerAccount,
  { marketIndex: order.marketIndex, orderId: order.orderId }
);

// Same pattern as getFillPerpOrderIx but for spot markets.
const ix = await driftClient.getFillSpotOrderIx(
  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 driftClient.getTriggerOrderIx(
  userPubkey,
  userAccount,
  triggerOrder
);

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

// Params:
//   users: Array of { settleeUserAccountPublicKey, settleeUserAccount }
//   marketIndexes: number[] - perp market indexes to settle
 
const user = driftClient.getUser();
const ixs = await driftClient.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 driftClient.getJupiterSwapIxV6({
  inMarketIndex: 0,   // e.g. USDC
  outMarketIndex: 1,  // e.g. SOL
  amount: driftClient.convertToSpotPrecision(0, 10), // 10 USDC
  slippageBps: 50,    // 0.5% max slippage
});