@drift-labs/jit-proxy 0.10.1 → 0.10.2

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types/jit_proxy';
+export * from './jitProxyClient';
+export * from './jitter/jitterSniper';
+export * from './jitter/jitterShotgun';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/jit_proxy"), exports);
+__exportStar(require("./jitProxyClient"), exports);
+__exportStar(require("./jitter/jitterSniper"), exports);
+__exportStar(require("./jitter/jitterShotgun"), exports);

package/lib/jitProxyClient.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="bn.js" />
+import { BN, DriftClient, MarketType, PostOnlyParams, ReferrerInfo, TxParams, UserAccount } from '@drift-labs/sdk';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { TxSigAndSlot } from '@drift-labs/sdk/lib/tx/types';
+export declare type JitIxParams = {
+    takerKey: PublicKey;
+    takerStatsKey: PublicKey;
+    taker: UserAccount;
+    takerOrderId: number;
+    maxPosition: BN;
+    minPosition: BN;
+    bid: BN;
+    ask: BN;
+    postOnly: PostOnlyParams | null;
+    priceType?: PriceType;
+    referrerInfo?: ReferrerInfo;
+    subAccountId?: number;
+};
+export declare class PriceType {
+    static readonly LIMIT: {
+        limit: {};
+    };
+    static readonly ORACLE: {
+        oracle: {};
+    };
+}
+export declare type OrderConstraint = {
+    maxPosition: BN;
+    minPosition: BN;
+    marketIndex: number;
+    marketType: MarketType;
+};
+export declare class JitProxyClient {
+    private driftClient;
+    private program;
+    constructor({ driftClient, programId, }: {
+        driftClient: DriftClient;
+        programId: PublicKey;
+    });
+    jit(params: JitIxParams, txParams?: TxParams): Promise<TxSigAndSlot>;
+    getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, minPosition, bid, ask, postOnly, priceType, referrerInfo, subAccountId, }: JitIxParams): Promise<TransactionInstruction>;
+    getCheckOrderConstraintIx({ subAccountId, orderConstraints, }: {
+        subAccountId: number;
+        orderConstraints: OrderConstraint[];
+    }): Promise<TransactionInstruction>;
+}

package/lib/jitProxyClient.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitProxyClient = exports.PriceType = void 0;
+const sdk_1 = require("@drift-labs/sdk");
+const jit_proxy_1 = require("./types/jit_proxy");
+const anchor_1 = require("@coral-xyz/anchor");
+class PriceType {
+}
+exports.PriceType = PriceType;
+PriceType.LIMIT = { limit: {} };
+PriceType.ORACLE = { oracle: {} };
+class JitProxyClient {
+    constructor({ driftClient, programId, }) {
+        this.driftClient = driftClient;
+        this.program = new anchor_1.Program(jit_proxy_1.IDL, programId, driftClient.provider);
+    }
+    async jit(params, txParams) {
+        const ix = await this.getJitIx(params);
+        const tx = await this.driftClient.buildTransaction([ix], txParams);
+        return await this.driftClient.sendTransaction(tx);
+    }
+    async getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, minPosition, bid, ask, postOnly = null, priceType = PriceType.LIMIT, referrerInfo, subAccountId, }) {
+        subAccountId =
+            subAccountId !== undefined
+                ? subAccountId
+                : this.driftClient.activeSubAccountId;
+        const order = taker.orders.find((order) => order.orderId === takerOrderId);
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [taker, this.driftClient.getUserAccount(subAccountId)],
+            writableSpotMarketIndexes: (0, sdk_1.isVariant)(order.marketType, 'spot')
+                ? [order.marketIndex, sdk_1.QUOTE_SPOT_MARKET_INDEX]
+                : [],
+            writablePerpMarketIndexes: (0, sdk_1.isVariant)(order.marketType, 'perp')
+                ? [order.marketIndex]
+                : [],
+        });
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        if ((0, sdk_1.isVariant)(order.marketType, 'spot')) {
+            remainingAccounts.push({
+                pubkey: this.driftClient.getSpotMarketAccount(order.marketIndex).vault,
+                isWritable: false,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: this.driftClient.getQuoteSpotMarketAccount().vault,
+                isWritable: false,
+                isSigner: false,
+            });
+        }
+        const jitParams = {
+            takerOrderId,
+            maxPosition,
+            minPosition,
+            bid,
+            ask,
+            postOnly,
+            priceType,
+        };
+        return this.program.methods
+            .jit(jitParams)
+            .accounts({
+            taker: takerKey,
+            takerStats: takerStatsKey,
+            state: await this.driftClient.getStatePublicKey(),
+            user: await this.driftClient.getUserAccountPublicKey(subAccountId),
+            userStats: this.driftClient.getUserStatsAccountPublicKey(),
+            driftProgram: this.driftClient.program.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    async getCheckOrderConstraintIx({ subAccountId, orderConstraints, }) {
+        subAccountId =
+            subAccountId !== undefined
+                ? subAccountId
+                : this.driftClient.activeSubAccountId;
+        const readablePerpMarketIndex = [];
+        const readableSpotMarketIndexes = [];
+        for (const orderConstraint of orderConstraints) {
+            if ((0, sdk_1.isVariant)(orderConstraint.marketType, 'perp')) {
+                readablePerpMarketIndex.push(orderConstraint.marketIndex);
+            }
+            else {
+                readableSpotMarketIndexes.push(orderConstraint.marketIndex);
+            }
+        }
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [this.driftClient.getUserAccount(subAccountId)],
+            readableSpotMarketIndexes,
+            readablePerpMarketIndex,
+        });
+        return this.program.methods
+            .checkOrderConstraints(orderConstraints)
+            .accounts({
+            user: await this.driftClient.getUserAccountPublicKey(subAccountId),
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+}
+exports.JitProxyClient = JitProxyClient;

package/lib/jitter/baseJitter.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="bn.js" />
+import { JitProxyClient, PriceType } from '../jitProxyClient';
+import { PublicKey } from '@solana/web3.js';
+import { AuctionSubscriber, BN, DriftClient, Order, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+export declare type UserFilter = (userAccount: UserAccount, userKey: string, order: Order) => boolean;
+export declare type JitParams = {
+    bid: BN;
+    ask: BN;
+    minPosition: BN;
+    maxPosition: any;
+    priceType: PriceType;
+    subAccountId?: number;
+};
+export declare abstract class BaseJitter {
+    auctionSubscriber: AuctionSubscriber;
+    driftClient: DriftClient;
+    jitProxyClient: JitProxyClient;
+    userStatsMap: UserStatsMap;
+    perpParams: Map<number, JitParams>;
+    spotParams: Map<number, JitParams>;
+    onGoingAuctions: Map<string, Promise<void>>;
+    userFilter: UserFilter;
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }: {
+        driftClient: DriftClient;
+        auctionSubscriber: AuctionSubscriber;
+        jitProxyClient: JitProxyClient;
+        userStatsMap?: UserStatsMap;
+    });
+    subscribe(): Promise<void>;
+    createTryFill(taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string): () => Promise<void>;
+    getOrderSignatures(takerKey: string, orderId: number): string;
+    updatePerpParams(marketIndex: number, params: JitParams): void;
+    updateSpotParams(marketIndex: number, params: JitParams): void;
+    setUserFilter(userFilter: UserFilter | undefined): void;
+}

package/lib/jitter/baseJitter.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseJitter = void 0;
+const sdk_1 = require("@drift-labs/sdk");
+class BaseJitter {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }) {
+        this.perpParams = new Map();
+        this.spotParams = new Map();
+        this.onGoingAuctions = new Map();
+        this.auctionSubscriber = auctionSubscriber;
+        this.driftClient = driftClient;
+        this.jitProxyClient = jitProxyClient;
+        this.userStatsMap =
+            userStatsMap ||
+                new sdk_1.UserStatsMap(this.driftClient, {
+                    type: 'polling',
+                    accountLoader: new sdk_1.BulkAccountLoader(this.driftClient.connection, 'confirmed', 0),
+                });
+    }
+    async subscribe() {
+        await this.driftClient.subscribe();
+        await this.userStatsMap.subscribe();
+        await this.auctionSubscriber.subscribe();
+        this.auctionSubscriber.eventEmitter.on('onAccountUpdate', async (taker, takerKey, slot) => {
+            const takerKeyString = takerKey.toBase58();
+            const takerStatsKey = (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, taker.authority);
+            for (const order of taker.orders) {
+                if (!(0, sdk_1.isVariant)(order.status, 'open')) {
+                    continue;
+                }
+                if (!(0, sdk_1.hasAuctionPrice)(order, slot)) {
+                    continue;
+                }
+                if (this.userFilter) {
+                    if (this.userFilter(taker, takerKeyString, order)) {
+                        return;
+                    }
+                }
+                const orderSignature = this.getOrderSignatures(takerKeyString, order.orderId);
+                if (this.onGoingAuctions.has(orderSignature)) {
+                    continue;
+                }
+                if ((0, sdk_1.isVariant)(order.marketType, 'perp')) {
+                    if (!this.perpParams.has(order.marketIndex)) {
+                        return;
+                    }
+                    const perpMarketAccount = this.driftClient.getPerpMarketAccount(order.marketIndex);
+                    if (order.baseAssetAmount
+                        .sub(order.baseAssetAmountFilled)
+                        .lte(perpMarketAccount.amm.minOrderSize)) {
+                        return;
+                    }
+                    const promise = this.createTryFill(taker, takerKey, takerStatsKey, order, orderSignature).bind(this)();
+                    this.onGoingAuctions.set(orderSignature, promise);
+                }
+                else {
+                    if (!this.spotParams.has(order.marketIndex)) {
+                        return;
+                    }
+                    const spotMarketAccount = this.driftClient.getSpotMarketAccount(order.marketIndex);
+                    if (order.baseAssetAmount
+                        .sub(order.baseAssetAmountFilled)
+                        .lte(spotMarketAccount.minOrderSize)) {
+                        return;
+                    }
+                    const promise = this.createTryFill(taker, takerKey, takerStatsKey, order, orderSignature).bind(this)();
+                    this.onGoingAuctions.set(orderSignature, promise);
+                }
+            }
+        });
+    }
+    createTryFill(taker, takerKey, takerStatsKey, order, orderSignature) {
+        throw new Error('Not implemented');
+    }
+    getOrderSignatures(takerKey, orderId) {
+        return `${takerKey}-${orderId}`;
+    }
+    updatePerpParams(marketIndex, params) {
+        this.perpParams.set(marketIndex, params);
+    }
+    updateSpotParams(marketIndex, params) {
+        this.spotParams.set(marketIndex, params);
+    }
+    setUserFilter(userFilter) {
+        this.userFilter = userFilter;
+    }
+}
+exports.BaseJitter = BaseJitter;

package/lib/jitter/jitterShotgun.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="bn.js" />
+import { JitProxyClient, PriceType } from '../jitProxyClient';
+import { PublicKey } from '@solana/web3.js';
+import { AuctionSubscriber, BN, DriftClient, Order, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+import { BaseJitter } from './baseJitter';
+export declare type UserFilter = (userAccount: UserAccount, userKey: string, order: Order) => boolean;
+export declare type JitParams = {
+    bid: BN;
+    ask: BN;
+    minPosition: BN;
+    maxPosition: any;
+    priceType: PriceType;
+    subAccountId?: number;
+};
+export declare class JitterShotgun extends BaseJitter {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }: {
+        driftClient: DriftClient;
+        auctionSubscriber: AuctionSubscriber;
+        jitProxyClient: JitProxyClient;
+        userStatsMap?: UserStatsMap;
+    });
+    createTryFill(taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string): () => Promise<void>;
+}

package/lib/jitter/jitterShotgun.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitterShotgun = void 0;
+const baseJitter_1 = require("./baseJitter");
+class JitterShotgun extends baseJitter_1.BaseJitter {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }) {
+        super({
+            auctionSubscriber,
+            jitProxyClient,
+            driftClient,
+            userStatsMap,
+        });
+    }
+    createTryFill(taker, takerKey, takerStatsKey, order, orderSignature) {
+        return async () => {
+            let i = 0;
+            while (i < 10) {
+                const params = this.perpParams.get(order.marketIndex);
+                if (!params) {
+                    this.onGoingAuctions.delete(orderSignature);
+                    return;
+                }
+                const takerStats = await this.userStatsMap.mustGet(taker.authority.toString());
+                const referrerInfo = takerStats.getReferrerInfo();
+                console.log(`Trying to fill ${orderSignature}`);
+                try {
+                    const { txSig } = await this.jitProxyClient.jit({
+                        takerKey,
+                        takerStatsKey,
+                        taker,
+                        takerOrderId: order.orderId,
+                        maxPosition: params.maxPosition,
+                        minPosition: params.minPosition,
+                        bid: params.bid,
+                        ask: params.ask,
+                        postOnly: null,
+                        priceType: params.priceType,
+                        referrerInfo,
+                        subAccountId: params.subAccountId,
+                    });
+                    console.log(`Filled ${orderSignature} txSig ${txSig}`);
+                    await sleep(10000);
+                    this.onGoingAuctions.delete(orderSignature);
+                    return;
+                }
+                catch (e) {
+                    console.error(`Failed to fill ${orderSignature}`);
+                    if (e.message.includes('0x1770') || e.message.includes('0x1771')) {
+                        console.log('Order does not cross params yet, retrying');
+                    }
+                    else if (e.message.includes('0x1793')) {
+                        console.log('Oracle invalid, retrying');
+                    }
+                    else {
+                        await sleep(10000);
+                        this.onGoingAuctions.delete(orderSignature);
+                        return;
+                    }
+                }
+                i++;
+            }
+            this.onGoingAuctions.delete(orderSignature);
+        };
+    }
+}
+exports.JitterShotgun = JitterShotgun;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/jitter/jitterSniper.d.ts

@@ -0,0 +1,32 @@
+import { JitProxyClient } from '../jitProxyClient';
+import { PublicKey } from '@solana/web3.js';
+import { AuctionSubscriber, DriftClient, OraclePriceData, Order, SlotSubscriber, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+import { BaseJitter } from './baseJitter';
+declare type AuctionAndOrderDetails = {
+    slotsTilCross: number;
+    willCross: boolean;
+    bid: number;
+    ask: number;
+    auctionStartPrice: number;
+    auctionEndPrice: number;
+    stepSize: number;
+    oraclePrice: OraclePriceData;
+};
+export declare class JitterSniper extends BaseJitter {
+    slotSubscriber: SlotSubscriber;
+    userStatsMap: UserStatsMap;
+    constructor({ auctionSubscriber, slotSubscriber, jitProxyClient, driftClient, userStatsMap, }: {
+        driftClient: DriftClient;
+        slotSubscriber: SlotSubscriber;
+        auctionSubscriber: AuctionSubscriber;
+        jitProxyClient: JitProxyClient;
+        userStatsMap?: UserStatsMap;
+    });
+    createTryFill(taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string): () => Promise<void>;
+    getAuctionAndOrderDetails(order: Order): AuctionAndOrderDetails;
+    waitForSlotOrCrossOrExpiry(targetSlot: number, order: Order, initialDetails: AuctionAndOrderDetails): Promise<{
+        slot: number;
+        updatedDetails: AuctionAndOrderDetails;
+    }>;
+}
+export {};

package/lib/jitter/jitterSniper.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JitterSniper = void 0;
+const sdk_1 = require("@drift-labs/sdk");
+const baseJitter_1 = require("./baseJitter");
+class JitterSniper extends baseJitter_1.BaseJitter {
+    constructor({ auctionSubscriber, slotSubscriber, jitProxyClient, driftClient, userStatsMap, }) {
+        super({
+            auctionSubscriber,
+            jitProxyClient,
+            driftClient,
+            userStatsMap,
+        });
+        this.slotSubscriber = slotSubscriber;
+    }
+    createTryFill(taker, takerKey, takerStatsKey, order, orderSignature) {
+        return async () => {
+            const params = this.perpParams.get(order.marketIndex);
+            if (!params) {
+                this.onGoingAuctions.delete(orderSignature);
+                return;
+            }
+            const takerStats = await this.userStatsMap.mustGet(taker.authority.toString());
+            const referrerInfo = takerStats.getReferrerInfo();
+            const { slotsTilCross, willCross, bid, ask, auctionStartPrice, auctionEndPrice, stepSize, oraclePrice, } = this.getAuctionAndOrderDetails(order);
+            console.log(`
+				Taker wants to ${JSON.stringify(order.direction)}, order slot is ${order.slot.toNumber()},
+				My market: ${bid}@${ask},
+				Auction: ${auctionStartPrice} -> ${auctionEndPrice}, step size ${stepSize}
+				Current slot: ${this.slotSubscriber.currentSlot}, Order slot: ${order.slot.toNumber()},
+				Will cross?: ${willCross}
+				Slots to wait: ${slotsTilCross}. Target slot = ${order.slot.toNumber() + slotsTilCross}
+			`);
+            this.waitForSlotOrCrossOrExpiry(willCross
+                ? order.slot.toNumber() + slotsTilCross
+                : order.slot.toNumber() + order.auctionDuration + 1, order, {
+                slotsTilCross,
+                willCross,
+                bid,
+                ask,
+                auctionStartPrice,
+                auctionEndPrice,
+                stepSize,
+                oraclePrice,
+            }).then(async ({ slot, updatedDetails }) => {
+                if (slot === -1) {
+                    console.log('Auction expired without crossing');
+                    this.onGoingAuctions.delete(orderSignature);
+                    return;
+                }
+                const params = (0, sdk_1.isVariant)(order.marketType, 'perp')
+                    ? this.perpParams.get(order.marketIndex)
+                    : this.spotParams.get(order.marketIndex);
+                const bid = (0, sdk_1.isVariant)(params.priceType, 'oracle')
+                    ? (0, sdk_1.convertToNumber)(oraclePrice.price.add(params.bid), sdk_1.PRICE_PRECISION)
+                    : (0, sdk_1.convertToNumber)(params.bid, sdk_1.PRICE_PRECISION);
+                const ask = (0, sdk_1.isVariant)(params.priceType, 'oracle')
+                    ? (0, sdk_1.convertToNumber)(oraclePrice.price.add(params.ask), sdk_1.PRICE_PRECISION)
+                    : (0, sdk_1.convertToNumber)(params.ask, sdk_1.PRICE_PRECISION);
+                const auctionPrice = (0, sdk_1.convertToNumber)((0, sdk_1.getAuctionPrice)(order, slot, updatedDetails.oraclePrice.price), sdk_1.PRICE_PRECISION);
+                console.log(`
+					Expected auction price: ${auctionStartPrice + slotsTilCross * stepSize}
+					Actual auction price: ${auctionPrice}
+					-----------------
+					Looking for slot ${order.slot.toNumber() + slotsTilCross}
+					Got slot ${slot}
+				`);
+                console.log(`Trying to fill ${orderSignature} with:
+					market: ${bid}@${ask}
+					auction price: ${auctionPrice}
+					submitting" ${(0, sdk_1.convertToNumber)(params.bid, sdk_1.PRICE_PRECISION)}@${(0, sdk_1.convertToNumber)(params.ask, sdk_1.PRICE_PRECISION)}
+				`);
+                let i = 0;
+                while (i < 3) {
+                    try {
+                        const { txSig } = await this.jitProxyClient.jit({
+                            takerKey,
+                            takerStatsKey,
+                            taker,
+                            takerOrderId: order.orderId,
+                            maxPosition: params.maxPosition,
+                            minPosition: params.minPosition,
+                            bid: params.bid,
+                            ask: params.ask,
+                            postOnly: null,
+                            priceType: params.priceType,
+                            referrerInfo,
+                            subAccountId: params.subAccountId,
+                        });
+                        console.log(`Filled ${orderSignature} txSig ${txSig}`);
+                        await sleep(3000);
+                        this.onGoingAuctions.delete(orderSignature);
+                        return;
+                    }
+                    catch (e) {
+                        console.error(`Failed to fill ${orderSignature}`);
+                        if (e.message.includes('0x1770') || e.message.includes('0x1771')) {
+                            console.log('Order does not cross params yet');
+                        }
+                        else if (e.message.includes('0x1793')) {
+                            console.log('Oracle invalid');
+                        }
+                        else {
+                            await sleep(3000);
+                            this.onGoingAuctions.delete(orderSignature);
+                            return;
+                        }
+                    }
+                    await sleep(50);
+                    i++;
+                }
+            });
+            this.onGoingAuctions.delete(orderSignature);
+        };
+    }
+    getAuctionAndOrderDetails(order) {
+        // Find number of slots until the order is expected to be in cross
+        const params = (0, sdk_1.isVariant)(order.marketType, 'perp')
+            ? this.perpParams.get(order.marketIndex)
+            : this.spotParams.get(order.marketIndex);
+        const oraclePrice = (0, sdk_1.isVariant)(order.marketType, 'perp')
+            ? this.driftClient.getOracleDataForPerpMarket(order.marketIndex)
+            : this.driftClient.getOracleDataForSpotMarket(order.marketIndex);
+        const makerOrderDir = (0, sdk_1.isVariant)(order.direction, 'long') ? 'sell' : 'buy';
+        const auctionStartPrice = (0, sdk_1.convertToNumber)((0, sdk_1.isVariant)(order.orderType, 'oracle')
+            ? (0, sdk_1.getAuctionPriceForOracleOffsetAuction)(order, order.slot.toNumber(), oraclePrice.price)
+            : order.auctionStartPrice, sdk_1.PRICE_PRECISION);
+        const auctionEndPrice = (0, sdk_1.convertToNumber)((0, sdk_1.isVariant)(order.orderType, 'oracle')
+            ? (0, sdk_1.getAuctionPriceForOracleOffsetAuction)(order, order.slot.toNumber() + order.auctionDuration - 1, oraclePrice.price)
+            : order.auctionEndPrice, sdk_1.PRICE_PRECISION);
+        const bid = (0, sdk_1.isVariant)(params.priceType, 'oracle')
+            ? (0, sdk_1.convertToNumber)(oraclePrice.price.add(params.bid), sdk_1.PRICE_PRECISION)
+            : (0, sdk_1.convertToNumber)(params.bid, sdk_1.PRICE_PRECISION);
+        const ask = (0, sdk_1.isVariant)(params.priceType, 'oracle')
+            ? (0, sdk_1.convertToNumber)(oraclePrice.price.add(params.ask), sdk_1.PRICE_PRECISION)
+            : (0, sdk_1.convertToNumber)(params.ask, sdk_1.PRICE_PRECISION);
+        let slotsTilCross = 0;
+        let willCross = false;
+        const stepSize = (auctionEndPrice - auctionStartPrice) / (order.auctionDuration - 1);
+        while (slotsTilCross < order.auctionDuration) {
+            if (makerOrderDir === 'buy') {
+                if ((0, sdk_1.convertToNumber)((0, sdk_1.getAuctionPrice)(order, order.slot.toNumber() + slotsTilCross, oraclePrice.price), sdk_1.PRICE_PRECISION) <= bid) {
+                    willCross = true;
+                    break;
+                }
+            }
+            else {
+                if ((0, sdk_1.convertToNumber)((0, sdk_1.getAuctionPrice)(order, order.slot.toNumber() + slotsTilCross, oraclePrice.price), sdk_1.PRICE_PRECISION) >= ask) {
+                    willCross = true;
+                    break;
+                }
+            }
+            slotsTilCross++;
+        }
+        return {
+            slotsTilCross,
+            willCross,
+            bid,
+            ask,
+            auctionStartPrice,
+            auctionEndPrice,
+            stepSize,
+            oraclePrice,
+        };
+    }
+    async waitForSlotOrCrossOrExpiry(targetSlot, order, initialDetails) {
+        const auctionEndSlot = order.auctionDuration + order.slot.toNumber();
+        let currentDetails = initialDetails;
+        let willCross = initialDetails.willCross;
+        if (this.slotSubscriber.currentSlot > auctionEndSlot) {
+            return new Promise((resolve) => resolve({ slot: -1, updatedDetails: currentDetails }));
+        }
+        return new Promise((resolve) => {
+            // Immediately return if we are past target slot
+            const slotListener = (slot) => {
+                if (slot >= targetSlot && willCross) {
+                    resolve({ slot, updatedDetails: currentDetails });
+                }
+            };
+            // Otherwise listen for new slots in case we hit the target slot and we're gonna cross
+            this.slotSubscriber.eventEmitter.once('newSlot', slotListener);
+            // Update target slot as the bid/ask and the oracle changes
+            const intervalId = setInterval(async () => {
+                if (this.slotSubscriber.currentSlot >= auctionEndSlot) {
+                    this.slotSubscriber.eventEmitter.removeListener('newSlot', slotListener);
+                    clearInterval(intervalId);
+                    resolve({ slot: -1, updatedDetails: currentDetails });
+                }
+                currentDetails = this.getAuctionAndOrderDetails(order);
+                willCross = currentDetails.willCross;
+                if (willCross) {
+                    targetSlot = order.slot.toNumber() + currentDetails.slotsTilCross;
+                }
+            }, 50);
+        });
+    }
+}
+exports.JitterSniper = JitterSniper;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/types/jit_proxy.d.ts

@@ -0,0 +1,212 @@
+export declare type JitProxy = {
+    version: '0.10.2';
+    name: 'jit_proxy';
+    instructions: [
+        {
+            name: 'jit';
+            accounts: [
+                {
+                    name: 'state';
+                    isMut: false;
+                    isSigner: false;
+                },
+                {
+                    name: 'user';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'userStats';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'taker';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'takerStats';
+                    isMut: true;
+                    isSigner: false;
+                },
+                {
+                    name: 'authority';
+                    isMut: false;
+                    isSigner: true;
+                },
+                {
+                    name: 'driftProgram';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'params';
+                    type: {
+                        defined: 'JitParams';
+                    };
+                }
+            ];
+        },
+        {
+            name: 'checkOrderConstraints';
+            accounts: [
+                {
+                    name: 'user';
+                    isMut: false;
+                    isSigner: false;
+                }
+            ];
+            args: [
+                {
+                    name: 'constraints';
+                    type: {
+                        vec: {
+                            defined: 'OrderConstraint';
+                        };
+                    };
+                }
+            ];
+        }
+    ];
+    types: [
+        {
+            name: 'JitParams';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'takerOrderId';
+                        type: 'u32';
+                    },
+                    {
+                        name: 'maxPosition';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'minPosition';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'bid';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'ask';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'priceType';
+                        type: {
+                            defined: 'PriceType';
+                        };
+                    },
+                    {
+                        name: 'postOnly';
+                        type: {
+                            option: {
+                                defined: 'PostOnlyParam';
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'OrderConstraint';
+            type: {
+                kind: 'struct';
+                fields: [
+                    {
+                        name: 'maxPosition';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'minPosition';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'marketIndex';
+                        type: 'u16';
+                    },
+                    {
+                        name: 'marketType';
+                        type: {
+                            defined: 'MarketType';
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PostOnlyParam';
+            type: {
+                kind: 'enum';
+                variants: [
+                    {
+                        name: 'None';
+                    },
+                    {
+                        name: 'MustPostOnly';
+                    },
+                    {
+                        name: 'TryPostOnly';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'PriceType';
+            type: {
+                kind: 'enum';
+                variants: [
+                    {
+                        name: 'Limit';
+                    },
+                    {
+                        name: 'Oracle';
+                    }
+                ];
+            };
+        },
+        {
+            name: 'MarketType';
+            type: {
+                kind: 'enum';
+                variants: [
+                    {
+                        name: 'Perp';
+                    },
+                    {
+                        name: 'Spot';
+                    }
+                ];
+            };
+        }
+    ];
+    errors: [
+        {
+            code: 6000;
+            name: 'BidNotCrossed';
+            msg: 'BidNotCrossed';
+        },
+        {
+            code: 6001;
+            name: 'AskNotCrossed';
+            msg: 'AskNotCrossed';
+        },
+        {
+            code: 6002;
+            name: 'TakerOrderNotFound';
+            msg: 'TakerOrderNotFound';
+        },
+        {
+            code: 6003;
+            name: 'OrderSizeBreached';
+            msg: 'OrderSizeBreached';
+        }
+    ];
+};
+export declare const IDL: JitProxy;

package/lib/types/jit_proxy.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDL = void 0;
+exports.IDL = {
+    version: '0.10.2',
+    name: 'jit_proxy',
+    instructions: [
+        {
+            name: 'jit',
+            accounts: [
+                {
+                    name: 'state',
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: 'user',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'userStats',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'taker',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'takerStats',
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: 'authority',
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: 'driftProgram',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'params',
+                    type: {
+                        defined: 'JitParams',
+                    },
+                },
+            ],
+        },
+        {
+            name: 'checkOrderConstraints',
+            accounts: [
+                {
+                    name: 'user',
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: 'constraints',
+                    type: {
+                        vec: {
+                            defined: 'OrderConstraint',
+                        },
+                    },
+                },
+            ],
+        },
+    ],
+    types: [
+        {
+            name: 'JitParams',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'takerOrderId',
+                        type: 'u32',
+                    },
+                    {
+                        name: 'maxPosition',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'minPosition',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'bid',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'ask',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'priceType',
+                        type: {
+                            defined: 'PriceType',
+                        },
+                    },
+                    {
+                        name: 'postOnly',
+                        type: {
+                            option: {
+                                defined: 'PostOnlyParam',
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'OrderConstraint',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'maxPosition',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'minPosition',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'marketIndex',
+                        type: 'u16',
+                    },
+                    {
+                        name: 'marketType',
+                        type: {
+                            defined: 'MarketType',
+                        },
+                    },
+                ],
+            },
+        },
+        {
+            name: 'PostOnlyParam',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'None',
+                    },
+                    {
+                        name: 'MustPostOnly',
+                    },
+                    {
+                        name: 'TryPostOnly',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'PriceType',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Limit',
+                    },
+                    {
+                        name: 'Oracle',
+                    },
+                ],
+            },
+        },
+        {
+            name: 'MarketType',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Perp',
+                    },
+                    {
+                        name: 'Spot',
+                    },
+                ],
+            },
+        },
+    ],
+    errors: [
+        {
+            code: 6000,
+            name: 'BidNotCrossed',
+            msg: 'BidNotCrossed',
+        },
+        {
+            code: 6001,
+            name: 'AskNotCrossed',
+            msg: 'AskNotCrossed',
+        },
+        {
+            code: 6002,
+            name: 'TakerOrderNotFound',
+            msg: 'TakerOrderNotFound',
+        },
+        {
+            code: 6003,
+            name: 'OrderSizeBreached',
+            msg: 'OrderSizeBreached',
+        },
+    ],
+};

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@drift-labs/jit-proxy",
-  "version": "0.10.1",
+  "version": "0.10.2",
+  "scripts": {
+    "clean": "rm -rf lib",
+    "build": "yarn clean && tsc"
+  },
   "dependencies": {
     "@coral-xyz/anchor": "^0.26.0",
     "@solana/web3.js": "1.73.2",

package/src/types/jit_proxy.ts

@@ -1,5 +1,5 @@
 export type JitProxy = {
-	version: '0.10.1';
+	version: '0.10.2';
 	name: 'jit_proxy';
 	instructions: [
 		{
@@ -211,7 +211,7 @@ export type JitProxy = {
 };
 
 export const IDL: JitProxy = {
-	version: '0.10.1',
+	version: '0.10.2',
 	name: 'jit_proxy',
 	instructions: [
 		{