@drift-labs/jit-proxy 0.12.65 → 0.12.67

package/lib/jitProxyClient.d.ts

@@ -2,6 +2,7 @@
 import { BN, DriftClient, MakerInfo, MarketType, PostOnlyParams, ReferrerInfo, TxParams, UserAccount } from '@drift-labs/sdk';
 import { PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { TxSigAndSlot } from '@drift-labs/sdk';
+import { SignedSwiftOrderParams } from '@drift-labs/sdk/lib/node/swift/types';
 export type JitIxParams = {
     takerKey: PublicKey;
     takerStatsKey: PublicKey;
@@ -16,6 +17,12 @@ export type JitIxParams = {
     referrerInfo?: ReferrerInfo;
     subAccountId?: number;
 };
+export type JitSwiftIxParams = JitIxParams & {
+    authorityToUse: PublicKey;
+    signedSwiftOrderParams: SignedSwiftOrderParams;
+    uuid: Uint8Array;
+    marketIndex: number;
+};
 export declare class PriceType {
     static readonly LIMIT: {
         limit: {};
@@ -38,7 +45,9 @@ export declare class JitProxyClient {
         programId: PublicKey;
     });
     jit(params: JitIxParams, txParams?: TxParams): Promise<TxSigAndSlot>;
+    jitSwift(params: JitSwiftIxParams, txParams?: TxParams, precedingIxs?: TransactionInstruction[]): Promise<TxSigAndSlot>;
     getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, minPosition, bid, ask, postOnly, priceType, referrerInfo, subAccountId, }: JitIxParams): Promise<TransactionInstruction>;
+    getJitSwiftIx({ takerKey, takerStatsKey, taker, maxPosition, minPosition, bid, ask, postOnly, priceType, referrerInfo, subAccountId, uuid, marketIndex, }: JitSwiftIxParams): Promise<TransactionInstruction>;
     getCheckOrderConstraintIx({ subAccountId, orderConstraints, }: {
         subAccountId: number;
         orderConstraints: OrderConstraint[];

package/lib/jitProxyClient.js

@@ -19,6 +19,16 @@ class JitProxyClient {
         const tx = await this.driftClient.buildTransaction([ix], txParams);
         return await this.driftClient.sendTransaction(tx);
     }
+    async jitSwift(params, txParams, precedingIxs) {
+        const swiftTakerIxs = await this.driftClient.getPlaceSwiftTakerPerpOrderIxs(params.signedSwiftOrderParams, params.marketIndex, {
+            taker: params.takerKey,
+            takerStats: params.takerStatsKey,
+            takerUserAccount: params.taker,
+        }, params.authorityToUse, precedingIxs);
+        const ix = await this.getJitSwiftIx(params);
+        const tx = await this.driftClient.buildTransaction([...swiftTakerIxs, 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
@@ -80,6 +90,52 @@ class JitProxyClient {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
+    async getJitSwiftIx({ takerKey, takerStatsKey, taker, maxPosition, minPosition, bid, ask, postOnly = null, priceType = PriceType.LIMIT, referrerInfo, subAccountId, uuid, marketIndex, }) {
+        subAccountId =
+            subAccountId !== undefined
+                ? subAccountId
+                : this.driftClient.activeSubAccountId;
+        const remainingAccounts = this.driftClient.getRemainingAccounts({
+            userAccounts: [taker, this.driftClient.getUserAccount(subAccountId)],
+            writableSpotMarketIndexes: [],
+            writablePerpMarketIndexes: [marketIndex],
+        });
+        if (referrerInfo) {
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrer,
+                isWritable: true,
+                isSigner: false,
+            });
+            remainingAccounts.push({
+                pubkey: referrerInfo.referrerStats,
+                isWritable: true,
+                isSigner: false,
+            });
+        }
+        const jitSwiftParams = {
+            swiftOrderUuid: Array.from(uuid),
+            maxPosition,
+            minPosition,
+            bid,
+            ask,
+            postOnly,
+            priceType,
+        };
+        return this.program.methods
+            .jitSwift(jitSwiftParams)
+            .accounts({
+            taker: takerKey,
+            takerStats: takerStatsKey,
+            takerSwiftUserOrders: (0, sdk_1.getSwiftUserAccountPublicKey)(this.driftClient.program.programId, taker.authority),
+            authority: this.driftClient.wallet.payer.publicKey,
+            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

package/lib/jitter/baseJitter.d.ts

@@ -1,7 +1,8 @@
 /// <reference types="bn.js" />
 import { JitProxyClient, PriceType } from '../jitProxyClient';
 import { PublicKey } from '@solana/web3.js';
-import { AuctionSubscriber, BN, DriftClient, Order, PostOnlyParams, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+import { AuctionSubscriber, BN, DriftClient, Order, PostOnlyParams, SlotSubscriber, SwiftOrderSubscriber, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+import { SignedSwiftOrderParams } from '@drift-labs/sdk/lib/node/swift/types';
 export type UserFilter = (userAccount: UserAccount, userKey: string, order: Order) => boolean;
 export type JitParams = {
     bid: BN;
@@ -14,6 +15,8 @@ export type JitParams = {
 };
 export declare abstract class BaseJitter {
     auctionSubscriber: AuctionSubscriber;
+    swiftOrderSubscriber: SwiftOrderSubscriber;
+    slotSubscriber: SlotSubscriber;
     driftClient: DriftClient;
     jitProxyClient: JitProxyClient;
     userStatsMap: UserStatsMap;
@@ -24,16 +27,20 @@ export declare abstract class BaseJitter {
     userFilter: UserFilter;
     computeUnits: number;
     computeUnitsPrice: number;
-    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }: {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, swiftOrderSubscriber, slotSubscriber, }: {
         driftClient: DriftClient;
         auctionSubscriber: AuctionSubscriber;
         jitProxyClient: JitProxyClient;
         userStatsMap: UserStatsMap;
+        swiftOrderSubscriber?: SwiftOrderSubscriber;
+        slotSubscriber?: SlotSubscriber;
     });
     subscribe(): Promise<void>;
     createTryFill(taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string): () => Promise<void>;
+    createTrySwiftFill(authorityToUse: PublicKey, signedSwiftOrderParams: SignedSwiftOrderParams, uuid: Uint8Array, taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string, marketIndex: number): () => Promise<void>;
     deleteOnGoingAuction(orderSignature: string): void;
     getOrderSignatures(takerKey: string, orderId: number): string;
+    private convertUuidToNumber;
     updatePerpParams(marketIndex: number, params: JitParams): void;
     updateSpotParams(marketIndex: number, params: JitParams): void;
     setUserFilter(userFilter: UserFilter | undefined): void;

package/lib/jitter/baseJitter.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseJitter = void 0;
+const web3_js_1 = require("@solana/web3.js");
 const sdk_1 = require("@drift-labs/sdk");
+const tweetnacl_util_1 = require("tweetnacl-util");
 class BaseJitter {
-    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }) {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, swiftOrderSubscriber, slotSubscriber, }) {
         this.perpParams = new Map();
         this.spotParams = new Map();
         this.seenOrders = new Set();
@@ -14,8 +16,14 @@ class BaseJitter {
         this.userStatsMap =
             userStatsMap ||
                 new sdk_1.UserStatsMap(this.driftClient, new sdk_1.BulkAccountLoader(this.driftClient.connection, 'confirmed', 0));
+        this.slotSubscriber = slotSubscriber;
+        this.swiftOrderSubscriber = swiftOrderSubscriber;
+        if (this.swiftOrderSubscriber && !this.slotSubscriber) {
+            throw new Error('Slot subscriber is required for swift order subscriber');
+        }
     }
     async subscribe() {
+        var _a, _b;
         await this.driftClient.subscribe();
         await this.auctionSubscriber.subscribe();
         this.auctionSubscriber.eventEmitter.on('onAccountUpdate', async (taker, takerKey, slot) => {
@@ -69,10 +77,78 @@ class BaseJitter {
                 }
             }
         });
+        await ((_a = this.slotSubscriber) === null || _a === void 0 ? void 0 : _a.subscribe());
+        await ((_b = this.swiftOrderSubscriber) === null || _b === void 0 ? void 0 : _b.subscribe(async (orderMessageRaw, swiftOrderParamsMessage) => {
+            var _a, _b, _c;
+            const swiftOrderParamsBufHex = Buffer.from(orderMessageRaw['order_message']);
+            const swiftOrderParamsBuf = Buffer.from(orderMessageRaw['order_message'], 'hex');
+            const { swiftOrderParams, subAccountId: takerSubaccountId, } = this.driftClient.decodeSwiftOrderParamsMessage(swiftOrderParamsBuf);
+            const takerAuthority = new web3_js_1.PublicKey(orderMessageRaw['taker_authority']);
+            const takerUserPubkey = await (0, sdk_1.getUserAccountPublicKey)(this.driftClient.program.programId, takerAuthority, takerSubaccountId);
+            const takerUserPubkeyString = takerUserPubkey.toBase58();
+            const takerUserAccount = (await this.swiftOrderSubscriber.userMap.mustGet(takerUserPubkey.toString())).getUserAccount();
+            const swiftOrder = {
+                status: sdk_1.OrderStatus.OPEN,
+                orderType: swiftOrderParams.orderType,
+                orderId: this.convertUuidToNumber(orderMessageRaw['uuid']),
+                slot: swiftOrderParamsMessage.slot,
+                marketIndex: swiftOrderParams.marketIndex,
+                marketType: sdk_1.MarketType.PERP,
+                baseAssetAmount: swiftOrderParams.baseAssetAmount,
+                auctionDuration: swiftOrderParams.auctionDuration,
+                auctionStartPrice: swiftOrderParams.auctionStartPrice,
+                auctionEndPrice: swiftOrderParams.auctionEndPrice,
+                immediateOrCancel: swiftOrderParams.immediateOrCancel,
+                direction: swiftOrderParams.direction,
+                postOnly: false,
+                oraclePriceOffset: (_a = swiftOrderParams.oraclePriceOffset) !== null && _a !== void 0 ? _a : 0,
+                maxTs: (_b = swiftOrderParams.maxTs) !== null && _b !== void 0 ? _b : sdk_1.ZERO,
+                reduceOnly: swiftOrderParams.reduceOnly,
+                triggerCondition: swiftOrderParams.triggerCondition,
+                // Rest are not necessary and set for type conforming
+                price: sdk_1.ZERO,
+                existingPositionDirection: sdk_1.PositionDirection.LONG,
+                triggerPrice: sdk_1.ZERO,
+                baseAssetAmountFilled: sdk_1.ZERO,
+                quoteAssetAmountFilled: sdk_1.ZERO,
+                quoteAssetAmount: sdk_1.ZERO,
+                userOrderId: 0,
+            };
+            swiftOrder.price = (0, sdk_1.getAuctionPrice)(swiftOrder, (_c = this.slotSubscriber) === null || _c === void 0 ? void 0 : _c.getSlot(), this.driftClient.getOracleDataForPerpMarket(swiftOrder.marketIndex)
+                .price);
+            if (this.userFilter) {
+                if (this.userFilter(takerUserAccount, takerUserPubkeyString, swiftOrder)) {
+                    return;
+                }
+            }
+            const orderSignature = this.getOrderSignatures(takerUserPubkeyString, swiftOrder.orderId);
+            if (this.seenOrders.has(orderSignature)) {
+                return;
+            }
+            this.seenOrders.add(orderSignature);
+            if (this.onGoingAuctions.has(orderSignature)) {
+                return;
+            }
+            if (!this.perpParams.has(swiftOrder.marketIndex)) {
+                return;
+            }
+            const perpMarketAccount = this.driftClient.getPerpMarketAccount(swiftOrder.marketIndex);
+            if (swiftOrder.baseAssetAmount.lt(perpMarketAccount.amm.minOrderSize)) {
+                return;
+            }
+            const promise = this.createTrySwiftFill(takerAuthority, {
+                orderParams: swiftOrderParamsBufHex,
+                signature: Buffer.from(orderMessageRaw['order_signature'], 'base64'),
+            }, (0, tweetnacl_util_1.decodeUTF8)(orderMessageRaw['uuid']), takerUserAccount, takerUserPubkey, (0, sdk_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, takerUserAccount.authority), swiftOrder, orderSignature, orderMessageRaw['market_index']).bind(this)();
+            this.onGoingAuctions.set(orderSignature, promise);
+        }));
     }
     createTryFill(taker, takerKey, takerStatsKey, order, orderSignature) {
         throw new Error('Not implemented');
     }
+    createTrySwiftFill(authorityToUse, signedSwiftOrderParams, uuid, taker, takerKey, takerStatsKey, order, orderSignature, marketIndex) {
+        throw new Error('Not implemented');
+    }
     deleteOnGoingAuction(orderSignature) {
         this.onGoingAuctions.delete(orderSignature);
         this.seenOrders.delete(orderSignature);
@@ -80,6 +156,12 @@ class BaseJitter {
     getOrderSignatures(takerKey, orderId) {
         return `${takerKey}-${orderId}`;
     }
+    convertUuidToNumber(uuid) {
+        return uuid
+            .split('')
+            .reduce((n, c) => n * 64 +
+            '_~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.indexOf(c), 0);
+    }
     updatePerpParams(marketIndex, params) {
         this.perpParams.set(marketIndex, params);
     }

package/lib/jitter/jitterShotgun.d.ts

@@ -1,13 +1,17 @@
 import { JitProxyClient } from '../jitProxyClient';
 import { PublicKey } from '@solana/web3.js';
-import { AuctionSubscriber, DriftClient, Order, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+import { AuctionSubscriber, DriftClient, Order, SlotSubscriber, SwiftOrderSubscriber, UserAccount, UserStatsMap } from '@drift-labs/sdk';
 import { BaseJitter } from './baseJitter';
+import { SignedSwiftOrderParams } from '@drift-labs/sdk/lib/node/swift/types';
 export declare class JitterShotgun extends BaseJitter {
-    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }: {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, swiftOrderSubscriber, slotSubscriber, }: {
         driftClient: DriftClient;
         auctionSubscriber: AuctionSubscriber;
         jitProxyClient: JitProxyClient;
         userStatsMap?: UserStatsMap;
+        swiftOrderSubscriber?: SwiftOrderSubscriber;
+        slotSubscriber?: SlotSubscriber;
     });
     createTryFill(taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string): () => Promise<void>;
+    createTrySwiftFill(authorityToUse: PublicKey, signedSwiftOrderParams: SignedSwiftOrderParams, uuid: Uint8Array, taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string, marketIndex: number): () => Promise<void>;
 }

package/lib/jitter/jitterShotgun.js

@@ -4,12 +4,14 @@ exports.JitterShotgun = void 0;
 const sdk_1 = require("@drift-labs/sdk");
 const baseJitter_1 = require("./baseJitter");
 class JitterShotgun extends baseJitter_1.BaseJitter {
-    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, }) {
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, userStatsMap, swiftOrderSubscriber, slotSubscriber, }) {
         super({
             auctionSubscriber,
             jitProxyClient,
             driftClient,
             userStatsMap,
+            swiftOrderSubscriber,
+            slotSubscriber,
         });
     }
     createTryFill(taker, takerKey, takerStatsKey, order, orderSignature) {
@@ -72,6 +74,71 @@ class JitterShotgun extends baseJitter_1.BaseJitter {
             this.deleteOnGoingAuction(orderSignature);
         };
     }
+    createTrySwiftFill(authorityToUse, signedSwiftOrderParams, uuid, taker, takerKey, takerStatsKey, order, orderSignature, marketIndex) {
+        return async () => {
+            var _a;
+            let i = 0;
+            const takerStats = await this.userStatsMap.mustGet(taker.authority.toString());
+            const referrerInfo = takerStats.getReferrerInfo();
+            // assumes each preflight simulation takes ~1 slot
+            while (i < order.auctionDuration) {
+                const params = this.perpParams.get(order.marketIndex);
+                if (!params) {
+                    this.deleteOnGoingAuction(orderSignature);
+                    return;
+                }
+                const txParams = {
+                    computeUnits: this.computeUnits,
+                    computeUnitsPrice: this.computeUnitsPrice,
+                };
+                console.log(`Trying to fill ${orderSignature}`);
+                try {
+                    const { txSig } = await this.jitProxyClient.jitSwift({
+                        takerKey,
+                        takerStatsKey,
+                        taker,
+                        takerOrderId: order.orderId,
+                        maxPosition: params.maxPosition,
+                        minPosition: params.minPosition,
+                        bid: params.bid,
+                        ask: params.ask,
+                        postOnly: (_a = params.postOnlyParams) !== null && _a !== void 0 ? _a : sdk_1.PostOnlyParams.MUST_POST_ONLY,
+                        priceType: params.priceType,
+                        referrerInfo,
+                        subAccountId: params.subAccountId,
+                        authorityToUse,
+                        signedSwiftOrderParams,
+                        uuid,
+                        marketIndex,
+                    }, txParams);
+                    console.log(`Successfully sent tx for ${orderSignature} txSig ${txSig}`);
+                    await sleep(10000);
+                    this.deleteOnGoingAuction(orderSignature);
+                    return;
+                }
+                catch (e) {
+                    console.error(`Failed to fill ${orderSignature}`);
+                    console.log(e);
+                    if (e.message.includes('0x1770') || e.message.includes('0x1771')) {
+                        console.log('Order does not cross params yet, retrying');
+                    }
+                    else if (e.message.includes('0x1779')) {
+                        console.log('Order could not fill');
+                    }
+                    else if (e.message.includes('0x1793')) {
+                        console.log('Oracle invalid, retrying');
+                    }
+                    else {
+                        await sleep(10000);
+                        this.deleteOnGoingAuction(orderSignature);
+                        return;
+                    }
+                }
+                i++;
+            }
+            this.deleteOnGoingAuction(orderSignature);
+        };
+    }
 }
 exports.JitterShotgun = JitterShotgun;
 function sleep(ms) {

package/lib/jitter/jitterSniper.d.ts

@@ -1,7 +1,8 @@
 import { JitProxyClient } from '../jitProxyClient';
 import { PublicKey } from '@solana/web3.js';
-import { AuctionSubscriber, DriftClient, OraclePriceData, Order, SlotSubscriber, UserAccount, UserStatsMap } from '@drift-labs/sdk';
+import { AuctionSubscriber, DriftClient, OraclePriceData, Order, SlotSubscriber, SwiftOrderSubscriber, UserAccount, UserStatsMap } from '@drift-labs/sdk';
 import { BaseJitter } from './baseJitter';
+import { SignedSwiftOrderParams } from '@drift-labs/sdk/lib/node/swift/types';
 type AuctionAndOrderDetails = {
     slotsTilCross: number;
     willCross: boolean;
@@ -15,14 +16,16 @@ type AuctionAndOrderDetails = {
 export declare class JitterSniper extends BaseJitter {
     slotSubscriber: SlotSubscriber;
     userStatsMap: UserStatsMap;
-    constructor({ auctionSubscriber, slotSubscriber, jitProxyClient, driftClient, userStatsMap, }: {
+    constructor({ auctionSubscriber, slotSubscriber, jitProxyClient, driftClient, userStatsMap, swiftOrderSubscriber, }: {
         driftClient: DriftClient;
         slotSubscriber: SlotSubscriber;
         auctionSubscriber: AuctionSubscriber;
         jitProxyClient: JitProxyClient;
         userStatsMap?: UserStatsMap;
+        swiftOrderSubscriber?: SwiftOrderSubscriber;
     });
     createTryFill(taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string): () => Promise<void>;
+    createTrySwiftFill(authorityToUse: PublicKey, signedSwiftOrderParams: SignedSwiftOrderParams, uuid: Uint8Array, taker: UserAccount, takerKey: PublicKey, takerStatsKey: PublicKey, order: Order, orderSignature: string, marketIndex: number): () => Promise<void>;
     getAuctionAndOrderDetails(order: Order): AuctionAndOrderDetails;
     waitForSlotOrCrossOrExpiry(targetSlot: number, order: Order, initialDetails: AuctionAndOrderDetails): Promise<{
         slot: number;

package/lib/jitter/jitterSniper.js

@@ -4,12 +4,14 @@ 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, }) {
+    constructor({ auctionSubscriber, slotSubscriber, jitProxyClient, driftClient, userStatsMap, swiftOrderSubscriber, }) {
         super({
             auctionSubscriber,
             jitProxyClient,
             driftClient,
             userStatsMap,
+            swiftOrderSubscriber,
+            slotSubscriber,
         });
         this.slotSubscriber = slotSubscriber;
     }
@@ -142,6 +144,139 @@ class JitterSniper extends baseJitter_1.BaseJitter {
             this.deleteOnGoingAuction(orderSignature);
         };
     }
+    createTrySwiftFill(authorityToUse, signedSwiftOrderParams, uuid, taker, takerKey, takerStatsKey, order, orderSignature, marketIndex) {
+        return async () => {
+            const params = this.perpParams.get(order.marketIndex);
+            if (!params) {
+                this.deleteOnGoingAuction(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);
+            // don't increase risk if we're past max positions
+            if ((0, sdk_1.isVariant)(order.marketType, 'perp')) {
+                const currPerpPos = this.driftClient.getUser().getPerpPosition(order.marketIndex) ||
+                    this.driftClient.getUser().getEmptyPosition(order.marketIndex);
+                if (currPerpPos.baseAssetAmount.lt(sdk_1.ZERO) &&
+                    (0, sdk_1.isVariant)(order.direction, 'short')) {
+                    if (currPerpPos.baseAssetAmount.lte(params.minPosition)) {
+                        console.log(`Order would increase existing short (mkt ${(0, sdk_1.getVariant)(order.marketType)}-${order.marketIndex}) too much`);
+                        this.deleteOnGoingAuction(orderSignature);
+                        return;
+                    }
+                }
+                else if (currPerpPos.baseAssetAmount.gt(sdk_1.ZERO) &&
+                    (0, sdk_1.isVariant)(order.direction, 'long')) {
+                    if (currPerpPos.baseAssetAmount.gte(params.maxPosition)) {
+                        console.log(`Order would increase existing long (mkt ${(0, sdk_1.getVariant)(order.marketType)}-${order.marketIndex}) too much`);
+                        this.deleteOnGoingAuction(orderSignature);
+                        return;
+                    }
+                }
+            }
+            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 }) => {
+                var _a;
+                if (slot === -1) {
+                    console.log('Auction expired without crossing');
+                    this.deleteOnGoingAuction(orderSignature);
+                    return;
+                }
+                const params = (0, sdk_1.isVariant)(order.marketType, 'perp')
+                    ? this.perpParams.get(order.marketIndex)
+                    : this.spotParams.get(order.marketIndex);
+                const bid = (0, sdk_1.isVariant)(params.priceType, 'oracle')
+                    ? (0, sdk_1.convertToNumber)(oraclePrice.price.add(params.bid), sdk_1.PRICE_PRECISION)
+                    : (0, sdk_1.convertToNumber)(params.bid, sdk_1.PRICE_PRECISION);
+                const ask = (0, sdk_1.isVariant)(params.priceType, 'oracle')
+                    ? (0, sdk_1.convertToNumber)(oraclePrice.price.add(params.ask), sdk_1.PRICE_PRECISION)
+                    : (0, sdk_1.convertToNumber)(params.ask, sdk_1.PRICE_PRECISION);
+                const auctionPrice = (0, sdk_1.convertToNumber)((0, sdk_1.getAuctionPrice)(order, slot, updatedDetails.oraclePrice.price), sdk_1.PRICE_PRECISION);
+                console.log(`
+					Expected auction price: ${auctionStartPrice + slotsTilCross * stepSize}
+					Actual auction price: ${auctionPrice}
+					-----------------
+					Looking for slot ${order.slot.toNumber() + slotsTilCross}
+					Got slot ${slot}
+				`);
+                console.log(`Trying to fill ${orderSignature} with:
+					market: ${bid}@${ask}
+					auction price: ${auctionPrice}
+					submitting" ${(0, sdk_1.convertToNumber)(params.bid, sdk_1.PRICE_PRECISION)}@${(0, sdk_1.convertToNumber)(params.ask, sdk_1.PRICE_PRECISION)}
+				`);
+                let i = 0;
+                while (i < 10) {
+                    try {
+                        const txParams = {
+                            computeUnits: this.computeUnits,
+                            computeUnitsPrice: this.computeUnitsPrice,
+                        };
+                        const { txSig } = await this.jitProxyClient.jitSwift({
+                            takerKey,
+                            takerStatsKey,
+                            taker,
+                            takerOrderId: order.orderId,
+                            maxPosition: params.maxPosition,
+                            minPosition: params.minPosition,
+                            bid: params.bid,
+                            ask: params.ask,
+                            postOnly: (_a = params.postOnlyParams) !== null && _a !== void 0 ? _a : sdk_1.PostOnlyParams.MUST_POST_ONLY,
+                            priceType: params.priceType,
+                            referrerInfo,
+                            subAccountId: params.subAccountId,
+                            authorityToUse,
+                            signedSwiftOrderParams,
+                            uuid,
+                            marketIndex,
+                        }, txParams);
+                        console.log(`Filled ${orderSignature} txSig ${txSig}`);
+                        await sleep(3000);
+                        this.deleteOnGoingAuction(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('0x1779')) {
+                            console.log('Order could not fill');
+                        }
+                        else if (e.message.includes('0x1793')) {
+                            console.log('Oracle invalid');
+                        }
+                        else {
+                            await sleep(3000);
+                            this.deleteOnGoingAuction(orderSignature);
+                            return;
+                        }
+                    }
+                    await sleep(200);
+                    i++;
+                }
+            });
+            this.deleteOnGoingAuction(orderSignature);
+        };
+    }
     getAuctionAndOrderDetails(order) {
         // Find number of slots until the order is expected to be in cross
         const params = (0, sdk_1.isVariant)(order.marketType, 'perp')