JIT-only MM

import { AuctionSubscriber } from "@drift-labs/sdk";
 
const auctionSubscriber = new AuctionSubscriber({
  driftClient,
  opts: { commitment: "processed" },
});
await auctionSubscriber.subscribe();

import { getAuctionPrice, convertToNumber, PRICE_PRECISION } from "@drift-labs/sdk";
 
const currentSlot = await connection.getSlot();
const oracle = driftClient.getOracleDataForPerpMarket(marketIndex);
 
// Get the current auction price at this slot
const auctionPriceBN = getAuctionPrice(takerOrder, currentSlot, oracle.price);
const auctionPrice = convertToNumber(auctionPriceBN, PRICE_PRECISION);
 
console.log(`Auction price at slot ${currentSlot}: $${auctionPrice.toFixed(4)}`);

import {
  AuctionSubscriber,
  getAuctionPrice,
  getUserStatsAccountPublicKey,
  isSignedMsgOrder,
  isVariant,
  convertToNumber,
  PRICE_PRECISION,
  BASE_PRECISION,
  OrderType,
  PositionDirection,
  PostOnlyParams,
} from "@drift-labs/sdk";
 
const MAX_POSITION = 100; // max 100 SOL position
const MIN_SPREAD = 0.02;  // minimum $0.02 edge required
 
const auctionSubscriber = new AuctionSubscriber({
  driftClient,
  opts: { commitment: "processed" },
});
await auctionSubscriber.subscribe();
 
// Listen for auction events instead of polling
auctionSubscriber.eventEmitter.on("onAccountUpdate", async (takerUserAccount, pubkey, slot) => {
  for (const order of takerUserAccount.orders) {
    if (order.baseAssetAmount.isZero() || order.baseAssetAmount.eq(order.baseAssetAmountFilled)) continue;
    const userAccount = takerUserAccount;
 
    // Skip SWIFT orders if handling them via SwiftOrderSubscriber
    if (isSignedMsgOrder(order)) continue;
 
    const marketIndex = order.marketIndex;
    const oracle = driftClient.getMMOracleDataForPerpMarket(marketIndex);
 
    // Check oracle validity
    if (!oracle.isValid) continue;
 
    // Check position limits
    const user = driftClient.getUser();
    const position = user.getPerpPosition(marketIndex);
    const currentSize = position
      ? Math.abs(convertToNumber(position.baseAssetAmount, BASE_PRECISION))
      : 0;
    const fillSize = convertToNumber(order.baseAssetAmount, BASE_PRECISION);
    if (currentSize + fillSize > MAX_POSITION) continue;
 
    // Get current auction price (use slot from the event, not an RPC call)
    const auctionPriceBN = getAuctionPrice(order, slot, oracle.price);
    const auctionPrice = convertToNumber(auctionPriceBN, PRICE_PRECISION);
    const oraclePrice = convertToNumber(oracle.price, PRICE_PRECISION);
 
    // Calculate our fill price (oracle + small edge)
    const takerIsLong = isVariant(order.direction, "long");
    const edge = MIN_SPREAD;
    const myFillPrice = takerIsLong
      ? oraclePrice + edge   // sell to long taker above oracle
      : oraclePrice - edge;  // buy from short taker below oracle
 
    // Check if our price is within the auction range
    const isCompetitive = takerIsLong
      ? myFillPrice <= auctionPrice
      : myFillPrice >= auctionPrice;
 
    if (!isCompetitive) continue;
 
    // Fill!
    try {
      await driftClient.placeAndMakePerpOrder(
        {
          orderType: OrderType.LIMIT,
          marketIndex,
          direction: takerIsLong ? PositionDirection.SHORT : PositionDirection.LONG,
          baseAssetAmount: order.baseAssetAmount.sub(order.baseAssetAmountFilled),
          price: driftClient.convertToPricePrecision(myFillPrice),
          postOnly: PostOnlyParams.MUST_POST_ONLY,
        },
        {
          taker: pubkey,
          takerStats: getUserStatsAccountPublicKey(driftClient.program.programId, userAccount.authority),
          takerUserAccount: userAccount,
          order,
        }
      );
      console.log(`Filled ${fillSize} @ $${myFillPrice.toFixed(4)}`);
    } catch (err) {
      console.error("Fill failed:", err);
    }
  }
});

import { JitterSniper, PriceType } from "@drift-labs/jit-proxy/lib";
 
const jitter = new JitterSniper({
  auctionSubscriber,
  driftClient,
  slotSubscriber,
});
 
await jitter.subscribe();
 
// The jitter handles auction timing automatically
// You just need to configure pricing and filters