@drift-labs/jit-proxy 0.9.0 → 0.10.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@drift-labs/jit-proxy",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "dependencies": {
     "@coral-xyz/anchor": "^0.26.0",
     "@solana/web3.js": "1.73.2",
-    "@drift-labs/sdk": "^2.38.0"
+    "@drift-labs/sdk": "^2.38.1-beta.7"
   },
   "engines": {
     "node": ">=16"

package/src/types/jit_proxy.ts

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

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,16 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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

@@ -1,46 +0,0 @@
-/// <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

@@ -1,112 +0,0 @@
-"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: sdk_1.isVariant(order.marketType, 'spot')
-                ? [order.marketIndex, sdk_1.QUOTE_SPOT_MARKET_INDEX]
-                : [],
-            writablePerpMarketIndexes: 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 (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 (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

@@ -1,35 +0,0 @@
-/// <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

@@ -1,88 +0,0 @@
-"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

@@ -1,23 +0,0 @@
-/// <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

@@ -1,69 +0,0 @@
-"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

@@ -1,32 +0,0 @@
-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

@@ -1,201 +0,0 @@
-"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/lib/jitter.d.ts

@@ -1,35 +0,0 @@
-/// <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 class Jitter {
-    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.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Jitter = void 0;
-const sdk_1 = require("@drift-labs/sdk");
-class Jitter {
-    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 promise = this.createTryFill(taker, takerKey, takerStatsKey, order, orderSignature).bind(this)();
-                    this.onGoingAuctions.set(orderSignature, promise);
-                }
-                else {
-                    if (!this.spotParams.has(order.marketIndex)) {
-                        return;
-                    }
-                    const promise = this.createTryFill(taker, takerKey, takerStatsKey, order, orderSignature).bind(this)();
-                    this.onGoingAuctions.set(orderSignature, promise);
-                }
-            }
-        });
-    }
-    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);
-        };
-    }
-    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.Jitter = Jitter;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/lib/types/jit_proxy.d.ts

@@ -1,212 +0,0 @@
-export declare type JitProxy = {
-    version: '0.9.0';
-    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

@@ -1,214 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IDL = void 0;
-exports.IDL = {
-    version: '0.9.0',
-    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',
-        },
-    ],
-};