@drift-labs/jit-proxy 0.6.0 → 0.7.0

package/lib/index.d.ts

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

package/lib/index.js

@@ -12,4 +12,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types/jit_proxy"), exports);
 __exportStar(require("./jitProxyClient"), exports);
-__exportStar(require("./jitter"), exports);
+__exportStar(require("./jitter/jitterSniper"), exports);
+__exportStar(require("./jitter/jitterShotgun"), exports);

package/lib/jitProxyClient.d.ts

@@ -32,5 +32,5 @@ export declare class JitProxyClient {
         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>;
+    getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, minPosition, bid, ask, postOnly, priceType, referrerInfo, subAccountId, }: JitIxParams): Promise<TransactionInstruction>;
 }

package/lib/jitProxyClient.js

@@ -19,8 +19,11 @@ class JitProxyClient {
         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;
+    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)],

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 = sdk_1.getUserStatsAccountPublicKey(this.driftClient.program.programId, taker.authority);
+            for (const order of taker.orders) {
+                if (!sdk_1.isVariant(order.status, 'open')) {
+                    continue;
+                }
+                if (!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 (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 = sdk_1.isVariant(order.marketType, 'perp')
+                    ? this.perpParams.get(order.marketIndex)
+                    : this.spotParams.get(order.marketIndex);
+                const bid = sdk_1.isVariant(params.priceType, 'oracle')
+                    ? sdk_1.convertToNumber(oraclePrice.price.add(params.bid), sdk_1.PRICE_PRECISION)
+                    : sdk_1.convertToNumber(params.bid, sdk_1.PRICE_PRECISION);
+                const ask = sdk_1.isVariant(params.priceType, 'oracle')
+                    ? sdk_1.convertToNumber(oraclePrice.price.add(params.ask), sdk_1.PRICE_PRECISION)
+                    : sdk_1.convertToNumber(params.ask, sdk_1.PRICE_PRECISION);
+                const auctionPrice = sdk_1.convertToNumber(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" ${sdk_1.convertToNumber(params.bid, sdk_1.PRICE_PRECISION)}@${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 = sdk_1.isVariant(order.marketType, 'perp')
+            ? this.perpParams.get(order.marketIndex)
+            : this.spotParams.get(order.marketIndex);
+        const oraclePrice = sdk_1.isVariant(order.marketType, 'perp')
+            ? this.driftClient.getOracleDataForPerpMarket(order.marketIndex)
+            : this.driftClient.getOracleDataForSpotMarket(order.marketIndex);
+        const makerOrderDir = sdk_1.isVariant(order.direction, 'long') ? 'sell' : 'buy';
+        const auctionStartPrice = sdk_1.convertToNumber(sdk_1.isVariant(order.orderType, 'oracle')
+            ? sdk_1.getAuctionPriceForOracleOffsetAuction(order, order.slot.toNumber(), oraclePrice.price)
+            : order.auctionStartPrice, sdk_1.PRICE_PRECISION);
+        const auctionEndPrice = sdk_1.convertToNumber(sdk_1.isVariant(order.orderType, 'oracle')
+            ? sdk_1.getAuctionPriceForOracleOffsetAuction(order, order.slot.toNumber() + order.auctionDuration - 1, oraclePrice.price)
+            : order.auctionEndPrice, sdk_1.PRICE_PRECISION);
+        const bid = sdk_1.isVariant(params.priceType, 'oracle')
+            ? sdk_1.convertToNumber(oraclePrice.price.add(params.bid), sdk_1.PRICE_PRECISION)
+            : sdk_1.convertToNumber(params.bid, sdk_1.PRICE_PRECISION);
+        const ask = sdk_1.isVariant(params.priceType, 'oracle')
+            ? sdk_1.convertToNumber(oraclePrice.price.add(params.ask), sdk_1.PRICE_PRECISION)
+            : 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 (sdk_1.convertToNumber(sdk_1.getAuctionPrice(order, order.slot.toNumber() + slotsTilCross, oraclePrice.price), sdk_1.PRICE_PRECISION) <= bid) {
+                    willCross = true;
+                    break;
+                }
+            }
+            else {
+                if (sdk_1.convertToNumber(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/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@drift-labs/jit-proxy",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "dependencies": {
     "@coral-xyz/anchor": "^0.26.0",
     "@solana/web3.js": "1.73.2",
-    "@drift-labs/sdk": "2.33.0"
+    "@drift-labs/sdk": "^2.37.1-beta.2"
   },
   "engines": {
     "node": ">=16"

package/src/index.ts

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

package/src/jitProxyClient.ts

@@ -69,9 +69,12 @@ export class JitProxyClient {
 		postOnly = null,
 		priceType = PriceType.LIMIT,
 		referrerInfo,
-		subAccountId
+		subAccountId,
 	}: JitIxParams): Promise<TransactionInstruction> {
-		subAccountId = subAccountId !== undefined ? subAccountId : this.driftClient.activeSubAccountId;
+		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)],

package/src/{jitter.ts → jitter/baseJitter.ts}

@@ -1,14 +1,23 @@
-import { JitProxyClient, PriceType } from './jitProxyClient';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { JitProxyClient, PriceType } from '../jitProxyClient';
 import { PublicKey } from '@solana/web3.js';
 import {
 	AuctionSubscriber,
-	BN, BulkAccountLoader,
+	BN,
+	BulkAccountLoader,
+	convertToNumber,
 	DriftClient,
+	getAuctionPrice,
+	getAuctionPriceForOracleOffsetAuction,
 	getUserStatsAccountPublicKey,
 	hasAuctionPrice,
 	isVariant,
+	OraclePriceData,
 	Order,
-	UserAccount, UserMap, UserStatsMap,
+	PRICE_PRECISION,
+	SlotSubscriber,
+	UserAccount,
+	UserStatsMap,
 } from '@drift-labs/sdk';
 
 export type UserFilter = (
@@ -26,7 +35,7 @@ export type JitParams = {
 	subAccountId?: number;
 };
 
-export class Jitter {
+export abstract class BaseJitter {
 	auctionSubscriber: AuctionSubscriber;
 	driftClient: DriftClient;
 	jitProxyClient: JitProxyClient;
@@ -53,10 +62,16 @@ export class Jitter {
 		this.auctionSubscriber = auctionSubscriber;
 		this.driftClient = driftClient;
 		this.jitProxyClient = jitProxyClient;
-		this.userStatsMap = userStatsMap || new UserStatsMap(this.driftClient, {
-			type: 'polling',
-			accountLoader: new BulkAccountLoader(this.driftClient.connection, 'confirmed', 0),
-		});
+		this.userStatsMap =
+			userStatsMap ||
+			new UserStatsMap(this.driftClient, {
+				type: 'polling',
+				accountLoader: new BulkAccountLoader(
+					this.driftClient.connection,
+					'confirmed',
+					0
+				),
+			});
 	}
 
 	async subscribe(): Promise<void> {
@@ -92,6 +107,7 @@ export class Jitter {
 						takerKeyString,
 						order.orderId
 					);
+
 					if (this.onGoingAuctions.has(orderSignature)) {
 						continue;
 					}
@@ -101,6 +117,17 @@ export class Jitter {
 							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,
@@ -114,6 +141,17 @@ export class Jitter {
 							return;
 						}
 
+						const spotMarketAccount = this.driftClient.getSpotMarketAccount(
+							order.marketIndex
+						);
+						if (
+							order.baseAssetAmount
+								.sub(order.baseAssetAmountFilled)
+								.lte(spotMarketAccount.minOrderSize)
+						) {
+							return;
+						}
+
 						const promise = this.createTryFill(
 							taker,
 							takerKey,
@@ -135,56 +173,7 @@ export class Jitter {
 		order: Order,
 		orderSignature: string
 	): () => Promise<void> {
-		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);
-		};
+		throw new Error('Not implemented');
 	}
 
 	getOrderSignatures(takerKey: string, orderId: number): string {
@@ -203,7 +192,3 @@ export class Jitter {
 		this.userFilter = userFilter;
 	}
 }
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/jitter/jitterShotgun.ts

@@ -0,0 +1,112 @@
+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 type UserFilter = (
+	userAccount: UserAccount,
+	userKey: string,
+	order: Order
+) => boolean;
+
+export type JitParams = {
+	bid: BN;
+	ask: BN;
+	minPosition: BN;
+	maxPosition;
+	priceType: PriceType;
+	subAccountId?: number;
+};
+
+export class JitterShotgun extends BaseJitter {
+	constructor({
+		auctionSubscriber,
+		jitProxyClient,
+		driftClient,
+		userStatsMap,
+	}: {
+		driftClient: DriftClient;
+		auctionSubscriber: AuctionSubscriber;
+		jitProxyClient: JitProxyClient;
+		userStatsMap?: UserStatsMap;
+	}) {
+		super({
+			auctionSubscriber,
+			jitProxyClient,
+			driftClient,
+			userStatsMap,
+		});
+	}
+
+	createTryFill(
+		taker: UserAccount,
+		takerKey: PublicKey,
+		takerStatsKey: PublicKey,
+		order: Order,
+		orderSignature: string
+	): () => Promise<void> {
+		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);
+		};
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/jitter/jitterSniper.ts

@@ -0,0 +1,330 @@
+import { JitProxyClient } from '../jitProxyClient';
+import { PublicKey } from '@solana/web3.js';
+import {
+	AuctionSubscriber,
+	convertToNumber,
+	DriftClient,
+	getAuctionPrice,
+	getAuctionPriceForOracleOffsetAuction,
+	isVariant,
+	OraclePriceData,
+	Order,
+	PRICE_PRECISION,
+	SlotSubscriber,
+	UserAccount,
+	UserStatsMap,
+} from '@drift-labs/sdk';
+import { BaseJitter } from './baseJitter';
+
+type AuctionAndOrderDetails = {
+	slotsTilCross: number;
+	willCross: boolean;
+	bid: number;
+	ask: number;
+	auctionStartPrice: number;
+	auctionEndPrice: number;
+	stepSize: number;
+	oraclePrice: OraclePriceData;
+};
+
+export class JitterSniper extends BaseJitter {
+	slotSubscriber: SlotSubscriber;
+	userStatsMap: UserStatsMap;
+
+	constructor({
+		auctionSubscriber,
+		slotSubscriber,
+		jitProxyClient,
+		driftClient,
+		userStatsMap,
+	}: {
+		driftClient: DriftClient;
+		slotSubscriber: SlotSubscriber;
+		auctionSubscriber: AuctionSubscriber;
+		jitProxyClient: JitProxyClient;
+		userStatsMap?: UserStatsMap;
+	}) {
+		super({
+			auctionSubscriber,
+			jitProxyClient,
+			driftClient,
+			userStatsMap,
+		});
+		this.slotSubscriber = slotSubscriber;
+	}
+
+	createTryFill(
+		taker: UserAccount,
+		takerKey: PublicKey,
+		takerStatsKey: PublicKey,
+		order: Order,
+		orderSignature: string
+	): () => Promise<void> {
+		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 = isVariant(order.marketType, 'perp')
+					? this.perpParams.get(order.marketIndex)
+					: this.spotParams.get(order.marketIndex);
+				const bid = isVariant(params.priceType, 'oracle')
+					? convertToNumber(oraclePrice.price.add(params.bid), PRICE_PRECISION)
+					: convertToNumber(params.bid, PRICE_PRECISION);
+				const ask = isVariant(params.priceType, 'oracle')
+					? convertToNumber(oraclePrice.price.add(params.ask), PRICE_PRECISION)
+					: convertToNumber(params.ask, PRICE_PRECISION);
+				const auctionPrice = convertToNumber(
+					getAuctionPrice(order, slot, updatedDetails.oraclePrice.price),
+					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" ${convertToNumber(params.bid, PRICE_PRECISION)}@${convertToNumber(
+					params.ask,
+					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: Order): AuctionAndOrderDetails {
+		// Find number of slots until the order is expected to be in cross
+		const params = isVariant(order.marketType, 'perp')
+			? this.perpParams.get(order.marketIndex)
+			: this.spotParams.get(order.marketIndex);
+		const oraclePrice = isVariant(order.marketType, 'perp')
+			? this.driftClient.getOracleDataForPerpMarket(order.marketIndex)
+			: this.driftClient.getOracleDataForSpotMarket(order.marketIndex);
+
+		const makerOrderDir = isVariant(order.direction, 'long') ? 'sell' : 'buy';
+		const auctionStartPrice = convertToNumber(
+			isVariant(order.orderType, 'oracle')
+				? getAuctionPriceForOracleOffsetAuction(
+						order,
+						order.slot.toNumber(),
+						oraclePrice.price
+				  )
+				: order.auctionStartPrice,
+			PRICE_PRECISION
+		);
+		const auctionEndPrice = convertToNumber(
+			isVariant(order.orderType, 'oracle')
+				? getAuctionPriceForOracleOffsetAuction(
+						order,
+						order.slot.toNumber() + order.auctionDuration - 1,
+						oraclePrice.price
+				  )
+				: order.auctionEndPrice,
+			PRICE_PRECISION
+		);
+
+		const bid = isVariant(params.priceType, 'oracle')
+			? convertToNumber(oraclePrice.price.add(params.bid), PRICE_PRECISION)
+			: convertToNumber(params.bid, PRICE_PRECISION);
+		const ask = isVariant(params.priceType, 'oracle')
+			? convertToNumber(oraclePrice.price.add(params.ask), PRICE_PRECISION)
+			: convertToNumber(params.ask, PRICE_PRECISION);
+
+		let slotsTilCross = 0;
+		let willCross = false;
+		const stepSize =
+			(auctionEndPrice - auctionStartPrice) / (order.auctionDuration - 1);
+		while (slotsTilCross < order.auctionDuration) {
+			if (makerOrderDir === 'buy') {
+				if (
+					convertToNumber(
+						getAuctionPrice(
+							order,
+							order.slot.toNumber() + slotsTilCross,
+							oraclePrice.price
+						),
+						PRICE_PRECISION
+					) <= bid
+				) {
+					willCross = true;
+					break;
+				}
+			} else {
+				if (
+					convertToNumber(
+						getAuctionPrice(
+							order,
+							order.slot.toNumber() + slotsTilCross,
+							oraclePrice.price
+						),
+						PRICE_PRECISION
+					) >= ask
+				) {
+					willCross = true;
+					break;
+				}
+			}
+			slotsTilCross++;
+		}
+
+		return {
+			slotsTilCross,
+			willCross,
+			bid,
+			ask,
+			auctionStartPrice,
+			auctionEndPrice,
+			stepSize,
+			oraclePrice,
+		};
+	}
+
+	async waitForSlotOrCrossOrExpiry(
+		targetSlot: number,
+		order: Order,
+		initialDetails: AuctionAndOrderDetails
+	): Promise<{ slot: number; updatedDetails: AuctionAndOrderDetails }> {
+		const auctionEndSlot = order.auctionDuration + order.slot.toNumber();
+		let currentDetails: AuctionAndOrderDetails = 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: number) => {
+				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);
+		});
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}