@drift-labs/jit-proxy 0.12.65 → 0.12.67

package/src/jitter/jitterShotgun.ts

@@ -5,10 +5,13 @@ import {
 	DriftClient,
 	Order,
 	PostOnlyParams,
+	SlotSubscriber,
+	SwiftOrderSubscriber,
 	UserAccount,
 	UserStatsMap,
 } from '@drift-labs/sdk';
 import { BaseJitter } from './baseJitter';
+import { SignedSwiftOrderParams } from '@drift-labs/sdk/lib/node/swift/types';
 
 export class JitterShotgun extends BaseJitter {
 	constructor({
@@ -16,17 +19,23 @@ export class JitterShotgun extends BaseJitter {
 		jitProxyClient,
 		driftClient,
 		userStatsMap,
+		swiftOrderSubscriber,
+		slotSubscriber,
 	}: {
 		driftClient: DriftClient;
 		auctionSubscriber: AuctionSubscriber;
 		jitProxyClient: JitProxyClient;
 		userStatsMap?: UserStatsMap;
+		swiftOrderSubscriber?: SwiftOrderSubscriber;
+		slotSubscriber?: SlotSubscriber;
 	}) {
 		super({
 			auctionSubscriber,
 			jitProxyClient,
 			driftClient,
 			userStatsMap,
+			swiftOrderSubscriber,
+			slotSubscriber,
 		});
 	}
 
@@ -104,6 +113,90 @@ export class JitterShotgun extends BaseJitter {
 			this.deleteOnGoingAuction(orderSignature);
 		};
 	}
+
+	createTrySwiftFill(
+		authorityToUse: PublicKey,
+		signedSwiftOrderParams: SignedSwiftOrderParams,
+		uuid: Uint8Array,
+		taker: UserAccount,
+		takerKey: PublicKey,
+		takerStatsKey: PublicKey,
+		order: Order,
+		orderSignature: string,
+		marketIndex: number
+	): () => Promise<void> {
+		return async () => {
+			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: params.postOnlyParams ?? 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);
+		};
+	}
 }
 
 function sleep(ms: number): Promise<void> {

package/src/jitter/jitterSniper.ts

@@ -14,11 +14,13 @@ import {
 	PostOnlyParams,
 	PRICE_PRECISION,
 	SlotSubscriber,
+	SwiftOrderSubscriber,
 	UserAccount,
 	UserStatsMap,
 	ZERO,
 } from '@drift-labs/sdk';
 import { BaseJitter } from './baseJitter';
+import { SignedSwiftOrderParams } from '@drift-labs/sdk/lib/node/swift/types';
 
 type AuctionAndOrderDetails = {
 	slotsTilCross: number;
@@ -41,18 +43,22 @@ export class JitterSniper extends BaseJitter {
 		jitProxyClient,
 		driftClient,
 		userStatsMap,
+		swiftOrderSubscriber,
 	}: {
 		driftClient: DriftClient;
 		slotSubscriber: SlotSubscriber;
 		auctionSubscriber: AuctionSubscriber;
 		jitProxyClient: JitProxyClient;
 		userStatsMap?: UserStatsMap;
+		swiftOrderSubscriber?: SwiftOrderSubscriber;
 	}) {
 		super({
 			auctionSubscriber,
 			jitProxyClient,
 			driftClient,
 			userStatsMap,
+			swiftOrderSubscriber,
+			slotSubscriber,
 		});
 		this.slotSubscriber = slotSubscriber;
 	}
@@ -239,6 +245,196 @@ export class JitterSniper extends BaseJitter {
 		};
 	}
 
+	createTrySwiftFill(
+		authorityToUse: PublicKey,
+		signedSwiftOrderParams: SignedSwiftOrderParams,
+		uuid: Uint8Array,
+		taker: UserAccount,
+		takerKey: PublicKey,
+		takerStatsKey: PublicKey,
+		order: Order,
+		orderSignature: string,
+		marketIndex: number
+	): () => Promise<void> {
+		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 (isVariant(order.marketType, 'perp')) {
+				const currPerpPos =
+					this.driftClient.getUser().getPerpPosition(order.marketIndex) ||
+					this.driftClient.getUser().getEmptyPosition(order.marketIndex);
+				if (
+					currPerpPos.baseAssetAmount.lt(ZERO) &&
+					isVariant(order.direction, 'short')
+				) {
+					if (currPerpPos.baseAssetAmount.lte(params.minPosition)) {
+						console.log(
+							`Order would increase existing short (mkt ${getVariant(
+								order.marketType
+							)}-${order.marketIndex}) too much`
+						);
+						this.deleteOnGoingAuction(orderSignature);
+						return;
+					}
+				} else if (
+					currPerpPos.baseAssetAmount.gt(ZERO) &&
+					isVariant(order.direction, 'long')
+				) {
+					if (currPerpPos.baseAssetAmount.gte(params.maxPosition)) {
+						console.log(
+							`Order would increase existing long (mkt ${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 }) => {
+				if (slot === -1) {
+					console.log('Auction expired without crossing');
+					this.deleteOnGoingAuction(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 < 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:
+									params.postOnlyParams ?? 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: Order): AuctionAndOrderDetails {
 		// Find number of slots until the order is expected to be in cross
 		const params = isVariant(order.marketType, 'perp')

package/src/types/jit_proxy.ts

@@ -1,5 +1,5 @@
 export type JitProxy = {
-	version: '0.10.2';
+	version: '0.12.0';
 	name: 'jit_proxy';
 	instructions: [
 		{
@@ -50,6 +50,59 @@ export type JitProxy = {
 				}
 			];
 		},
+		{
+			name: 'jitSwift';
+			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: 'takerSwiftUserOrders';
+					isMut: true;
+					isSigner: false;
+				},
+				{
+					name: 'authority';
+					isMut: false;
+					isSigner: true;
+				},
+				{
+					name: 'driftProgram';
+					isMut: false;
+					isSigner: false;
+				}
+			];
+			args: [
+				{
+					name: 'params';
+					type: {
+						defined: 'JitSwiftParams';
+					};
+				}
+			];
+		},
 		{
 			name: 'checkOrderConstraints';
 			accounts: [
@@ -176,6 +229,50 @@ export type JitProxy = {
 				];
 			};
 		},
+		{
+			name: 'JitSwiftParams';
+			type: {
+				kind: 'struct';
+				fields: [
+					{
+						name: 'swiftOrderUuid';
+						type: {
+							array: ['u8', 8];
+						};
+					},
+					{
+						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: 'PostOnlyParam';
 			type: {
@@ -275,12 +372,17 @@ export type JitProxy = {
 			code: 6009;
 			name: 'NoFill';
 			msg: 'NoFill';
+		},
+		{
+			code: 6010;
+			name: 'SwiftOrderDoesNotExist';
+			msg: 'SwiftOrderDoesNotExist';
 		}
 	];
 };
 
 export const IDL: JitProxy = {
-	version: '0.10.2',
+	version: '0.12.0',
 	name: 'jit_proxy',
 	instructions: [
 		{
@@ -331,6 +433,59 @@ export const IDL: JitProxy = {
 				},
 			],
 		},
+		{
+			name: 'jitSwift',
+			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: 'takerSwiftUserOrders',
+					isMut: true,
+					isSigner: false,
+				},
+				{
+					name: 'authority',
+					isMut: false,
+					isSigner: true,
+				},
+				{
+					name: 'driftProgram',
+					isMut: false,
+					isSigner: false,
+				},
+			],
+			args: [
+				{
+					name: 'params',
+					type: {
+						defined: 'JitSwiftParams',
+					},
+				},
+			],
+		},
 		{
 			name: 'checkOrderConstraints',
 			accounts: [
@@ -457,6 +612,50 @@ export const IDL: JitProxy = {
 				],
 			},
 		},
+		{
+			name: 'JitSwiftParams',
+			type: {
+				kind: 'struct',
+				fields: [
+					{
+						name: 'swiftOrderUuid',
+						type: {
+							array: ['u8', 8],
+						},
+					},
+					{
+						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: 'PostOnlyParam',
 			type: {
@@ -557,5 +756,10 @@ export const IDL: JitProxy = {
 			name: 'NoFill',
 			msg: 'NoFill',
 		},
+		{
+			code: 6010,
+			name: 'SwiftOrderDoesNotExist',
+			msg: 'SwiftOrderDoesNotExist',
+		},
 	],
 };