@drift-labs/jit-proxy 0.6.0 → 0.8.0

package/Readme.md

@@ -0,0 +1,58 @@
+# Jit Proxy SDK
+
+## Jit Proxy Client
+
+```JitProxyClient``` will create and send transactions to the jit proxy program. Instantiate a jit proxy client with a drift client and a program Id. The current public key for the jit proxy program is
+
+```J1TnP8zvVxbtF5KFp5xRmWuvG9McnhzmBd9XGfCyuxFP```. Example instantiation:
+
+```
+const jitProxyClient = new JitProxyClient({
+			driftClient,
+			programId: new PublicKey('J1TnP8zvVxbtF5KFp5xRmWuvG9McnhzmBd9XGfCyuxFP'),
+		});
+```
+
+## Jitter
+
+A jitter takes ```JitParams``` and uses them to determine when and how to use the ```JitProxyClient``` to send a transaction. For bots to make use of the jitter, they should create a jitter instance, and then set the ```JitParams``` according to their strategy for each market they are market making. ```JitParams``` are set on the Jitter object using ```updatePerpParams()``` and ```updateSpotParams()```. There are two kinds of Jitters that can be insantiated: ```JitterShotgun``` and ```JitterSniper```. The difference between the two is how orders are sent. 
+
+For ```JitterShotgun```, orders are sent immediately when detecting a new eligible auction. The JitterShotgun will try up to 10 times to fill the order, retrying every time the it receives back an error due to the order not crossing the bid/ask in the ```JitParams``` or the oracle price being invalid. 
+
+For ```JitterSniper```, orders are sent only when it detects that an order might cross the bid/ask of the ```JitParams```, waiting until the right slot, before sending up to 3 orders (retrying on errors). It will not send orders if the price of the order does not cross the bid/ask during the auction, unlike the JitterShotgun, which will immediately attempt.
+
+## Jit Params
+
+Type definition for the JitParmas is below:
+
+```
+export type JitParams = {
+	bid: BN;
+	ask: BN;
+	minPosition: BN;
+	maxPosition: BN;
+	priceType: PriceType;
+	subAccountId?: number;
+};
+```
+
+PriceType options are ```ORACLE``` and ```LIMIT```. Limit price type is the BN representaiton of an absolute price; i.e., price type of LIMIT and a market of bid: 10, ask: 11 means your market is 10@11. Oracle price types are offsets relative to the oralce price for a given slot. They are always added to the oracle price, so if the oracle price is 10.5, to get a market of 10@11 when price type is oracle, bid and ask are -0.5 and 0.5 respectively (Remember that bid and ask are of BN type, this example is for illustration purposes only. Remember to use BN math operations).
+
+## Example set up
+
+Example set up for the JitterSniper (assuming parameters are already initialized/subscribed to). JitterShotgun is instantiated and initialized in a similar manner.
+
+```
+const jitProxyClient = new JitProxyClient({
+			driftClient,
+			programId: new PublicKey('J1TnP8zvVxbtF5KFp5xRmWuvG9McnhzmBd9XGfCyuxFP'),
+		});
+
+		const jitter = new JitterSniper({
+			auctionSubscriber,
+			driftClient,
+			slotSubscriber,
+			jitProxyClient,
+		});
+		await jitter.subscribe();
+```

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.8.0",
   "dependencies": {
     "@coral-xyz/anchor": "^0.26.0",
     "@solana/web3.js": "1.73.2",
-    "@drift-labs/sdk": "2.33.0"
+    "@drift-labs/sdk": "^2.38.0"
   },
   "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));
+}