@drift-labs/jit-proxy 0.1.0 → 0.2.0

package/lib/index.d.ts

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

package/lib/index.js

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

package/lib/jitProxyClient.d.ts

@@ -8,9 +8,20 @@ export declare type JitIxParams = {
     taker: UserAccount;
     takerOrderId: number;
     maxPosition: BN;
-    worstPrice: BN;
+    minPosition: BN;
+    bid: BN;
+    ask: BN;
     postOnly: PostOnlyParams | null;
+    priceType?: PriceType;
 };
+export declare class PriceType {
+    static readonly LIMIT: {
+        limit: {};
+    };
+    static readonly ORACLE: {
+        oracle: {};
+    };
+}
 export declare class JitProxyClient {
     private driftClient;
     private program;
@@ -19,5 +30,5 @@ export declare class JitProxyClient {
         programId: PublicKey;
     });
     jit(params: JitIxParams, txParams?: TxParams): Promise<TxSigAndSlot>;
-    getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, worstPrice, postOnly, }: JitIxParams): Promise<TransactionInstruction>;
+    getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, minPosition, bid, ask, postOnly, priceType, }: JitIxParams): Promise<TransactionInstruction>;
 }

package/lib/jitProxyClient.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JitProxyClient = void 0;
+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;
@@ -14,7 +19,7 @@ class JitProxyClient {
         const tx = await this.driftClient.buildTransaction([ix], txParams);
         return await this.driftClient.sendTransaction(tx);
     }
-    async getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, worstPrice, postOnly = null, }) {
+    async getJitIx({ takerKey, takerStatsKey, taker, takerOrderId, maxPosition, minPosition, bid, ask, postOnly = null, priceType = PriceType.LIMIT, }) {
         const order = taker.orders.find((order) => order.orderId === takerOrderId);
         const remainingAccounts = this.driftClient.getRemainingAccounts({
             userAccounts: [taker, this.driftClient.getUserAccount()],
@@ -25,11 +30,26 @@ class JitProxyClient {
                 ? [order.marketIndex]
                 : [],
         });
+        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,
-            worstPrice,
+            minPosition,
+            bid,
+            ask,
             postOnly,
+            priceType,
         };
         return this.program.methods
             .jit(jitParams)

package/lib/jitter.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="bn.js" />
+import { JitProxyClient, PriceType } from './jitProxyClient';
+import { PublicKey } from '@solana/web3.js';
+import { AuctionSubscriber, BN, DriftClient, Order, UserAccount } 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;
+};
+export declare class Jitter {
+    auctionSubscriber: AuctionSubscriber;
+    driftClient: DriftClient;
+    jitProxyClient: JitProxyClient;
+    perpParams: Map<number, JitParams>;
+    spotParams: Map<number, JitParams>;
+    onGoingAuctions: Map<string, Promise<void>>;
+    userFilter: UserFilter;
+    constructor({ auctionSubscriber, jitProxyClient, driftClient, }: {
+        driftClient: DriftClient;
+        auctionSubscriber: AuctionSubscriber;
+        jitProxyClient: JitProxyClient;
+    });
+    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

@@ -0,0 +1,115 @@
+"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, }) {
+        this.perpParams = new Map();
+        this.spotParams = new Map();
+        this.onGoingAuctions = new Map();
+        this.auctionSubscriber = auctionSubscriber;
+        this.driftClient = driftClient;
+        this.jitProxyClient = jitProxyClient;
+    }
+    async 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;
+                }
+                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,
+                    });
+                    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

@@ -66,8 +66,22 @@ export declare type JitProxy = {
                         type: 'i64';
                     },
                     {
-                        name: 'worstPrice';
-                        type: 'u64';
+                        name: 'minPosition';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'bid';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'ask';
+                        type: 'i64';
+                    },
+                    {
+                        name: 'priceType';
+                        type: {
+                            defined: 'PriceType';
+                        };
                     },
                     {
                         name: 'postOnly';
@@ -96,16 +110,35 @@ export declare type JitProxy = {
                     }
                 ];
             };
+        },
+        {
+            name: 'PriceType';
+            type: {
+                kind: 'enum';
+                variants: [
+                    {
+                        name: 'Limit';
+                    },
+                    {
+                        name: 'Oracle';
+                    }
+                ];
+            };
         }
     ];
     errors: [
         {
             code: 6000;
-            name: 'WorstPriceExceeded';
-            msg: 'WorstPriceExceeded';
+            name: 'BidNotCrossed';
+            msg: 'BidNotCrossed';
         },
         {
             code: 6001;
+            name: 'AskNotCrossed';
+            msg: 'AskNotCrossed';
+        },
+        {
+            code: 6002;
             name: 'TakerOrderNotFound';
             msg: 'TakerOrderNotFound';
         }

package/lib/types/jit_proxy.js

@@ -69,8 +69,22 @@ exports.IDL = {
                         type: 'i64',
                     },
                     {
-                        name: 'worstPrice',
-                        type: 'u64',
+                        name: 'minPosition',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'bid',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'ask',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'priceType',
+                        type: {
+                            defined: 'PriceType',
+                        },
                     },
                     {
                         name: 'postOnly',
@@ -100,15 +114,34 @@ exports.IDL = {
                 ],
             },
         },
+        {
+            name: 'PriceType',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Limit',
+                    },
+                    {
+                        name: 'Oracle',
+                    },
+                ],
+            },
+        },
     ],
     errors: [
         {
             code: 6000,
-            name: 'WorstPriceExceeded',
-            msg: 'WorstPriceExceeded',
+            name: 'BidNotCrossed',
+            msg: 'BidNotCrossed',
         },
         {
             code: 6001,
+            name: 'AskNotCrossed',
+            msg: 'AskNotCrossed',
+        },
+        {
+            code: 6002,
             name: 'TakerOrderNotFound',
             msg: 'TakerOrderNotFound',
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drift-labs/jit-proxy",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "dependencies": {
     "@coral-xyz/anchor": "^0.26.0",
     "@solana/web3.js": "1.73.2",

package/src/index.ts

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

package/src/jitProxyClient.ts

@@ -18,10 +18,18 @@ export type JitIxParams = {
 	taker: UserAccount;
 	takerOrderId: number;
 	maxPosition: BN;
-	worstPrice: BN;
+	minPosition: BN;
+	bid: BN;
+	ask: BN;
 	postOnly: PostOnlyParams | null;
+	priceType?: PriceType;
 };
 
+export class PriceType {
+	static readonly LIMIT = { limit: {} };
+	static readonly ORACLE = { oracle: {} };
+}
+
 export class JitProxyClient {
 	private driftClient: DriftClient;
 	private program: Program<JitProxy>;
@@ -52,8 +60,11 @@ export class JitProxyClient {
 		taker,
 		takerOrderId,
 		maxPosition,
-		worstPrice,
+		minPosition,
+		bid,
+		ask,
 		postOnly = null,
+		priceType = PriceType.LIMIT,
 	}: JitIxParams): Promise<TransactionInstruction> {
 		const order = taker.orders.find((order) => order.orderId === takerOrderId);
 		const remainingAccounts = this.driftClient.getRemainingAccounts({
@@ -66,11 +77,27 @@ export class JitProxyClient {
 				: [],
 		});
 
+		if (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,
-			worstPrice,
+			minPosition,
+			bid,
+			ask,
 			postOnly,
+			priceType,
 		};
 
 		return this.program.methods

package/src/jitter.ts

@@ -0,0 +1,192 @@
+import { JitProxyClient, PriceType } from './jitProxyClient';
+import { PublicKey } from '@solana/web3.js';
+import {
+	AuctionSubscriber,
+	BN,
+	DriftClient,
+	getUserStatsAccountPublicKey,
+	hasAuctionPrice,
+	isVariant,
+	Order,
+	UserAccount,
+} from '@drift-labs/sdk';
+
+export type UserFilter = (
+	userAccount: UserAccount,
+	userKey: string,
+	order: Order
+) => boolean;
+export type JitParams = {
+	bid: BN;
+	ask: BN;
+	minPosition: BN;
+	maxPosition;
+	priceType: PriceType;
+};
+
+export class Jitter {
+	auctionSubscriber: AuctionSubscriber;
+	driftClient: DriftClient;
+	jitProxyClient: JitProxyClient;
+
+	perpParams = new Map<number, JitParams>();
+	spotParams = new Map<number, JitParams>();
+
+	onGoingAuctions = new Map<string, Promise<void>>();
+
+	userFilter: UserFilter;
+
+	constructor({
+		auctionSubscriber,
+		jitProxyClient,
+		driftClient,
+	}: {
+		driftClient: DriftClient;
+		auctionSubscriber: AuctionSubscriber;
+		jitProxyClient: JitProxyClient;
+	}) {
+		this.auctionSubscriber = auctionSubscriber;
+		this.driftClient = driftClient;
+		this.jitProxyClient = jitProxyClient;
+	}
+
+	async subscribe(): Promise<void> {
+		await this.auctionSubscriber.subscribe();
+		this.auctionSubscriber.eventEmitter.on(
+			'onAccountUpdate',
+			async (taker, takerKey, slot) => {
+				const takerKeyString = takerKey.toBase58();
+
+				const takerStatsKey = getUserStatsAccountPublicKey(
+					this.driftClient.program.programId,
+					taker.authority
+				);
+				for (const order of taker.orders) {
+					if (!isVariant(order.status, 'open')) {
+						continue;
+					}
+
+					if (!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 (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: UserAccount,
+		takerKey: PublicKey,
+		takerStatsKey: PublicKey,
+		order: Order,
+		orderSignature: string
+	): () => Promise<void> {
+		return async () => {
+			let i = 0;
+			while (i < 10) {
+				const params = this.perpParams.get(order.marketIndex);
+				if (!params) {
+					this.onGoingAuctions.delete(orderSignature);
+					return;
+				}
+
+				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,
+					});
+
+					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: string, orderId: number): string {
+		return `${takerKey}-${orderId}`;
+	}
+
+	public updatePerpParams(marketIndex: number, params: JitParams): void {
+		this.perpParams.set(marketIndex, params);
+	}
+
+	public updateSpotParams(marketIndex: number, params: JitParams): void {
+		this.spotParams.set(marketIndex, params);
+	}
+
+	public setUserFilter(userFilter: UserFilter | undefined): void {
+		this.userFilter = userFilter;
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/types/jit_proxy.ts

@@ -66,8 +66,22 @@ export type JitProxy = {
 						type: 'i64';
 					},
 					{
-						name: 'worstPrice';
-						type: 'u64';
+						name: 'minPosition';
+						type: 'i64';
+					},
+					{
+						name: 'bid';
+						type: 'i64';
+					},
+					{
+						name: 'ask';
+						type: 'i64';
+					},
+					{
+						name: 'priceType';
+						type: {
+							defined: 'PriceType';
+						};
 					},
 					{
 						name: 'postOnly';
@@ -96,16 +110,35 @@ export type JitProxy = {
 					}
 				];
 			};
+		},
+		{
+			name: 'PriceType';
+			type: {
+				kind: 'enum';
+				variants: [
+					{
+						name: 'Limit';
+					},
+					{
+						name: 'Oracle';
+					}
+				];
+			};
 		}
 	];
 	errors: [
 		{
 			code: 6000;
-			name: 'WorstPriceExceeded';
-			msg: 'WorstPriceExceeded';
+			name: 'BidNotCrossed';
+			msg: 'BidNotCrossed';
 		},
 		{
 			code: 6001;
+			name: 'AskNotCrossed';
+			msg: 'AskNotCrossed';
+		},
+		{
+			code: 6002;
 			name: 'TakerOrderNotFound';
 			msg: 'TakerOrderNotFound';
 		}
@@ -180,8 +213,22 @@ export const IDL: JitProxy = {
 						type: 'i64',
 					},
 					{
-						name: 'worstPrice',
-						type: 'u64',
+						name: 'minPosition',
+						type: 'i64',
+					},
+					{
+						name: 'bid',
+						type: 'i64',
+					},
+					{
+						name: 'ask',
+						type: 'i64',
+					},
+					{
+						name: 'priceType',
+						type: {
+							defined: 'PriceType',
+						},
 					},
 					{
 						name: 'postOnly',
@@ -211,15 +258,34 @@ export const IDL: JitProxy = {
 				],
 			},
 		},
+		{
+			name: 'PriceType',
+			type: {
+				kind: 'enum',
+				variants: [
+					{
+						name: 'Limit',
+					},
+					{
+						name: 'Oracle',
+					},
+				],
+			},
+		},
 	],
 	errors: [
 		{
 			code: 6000,
-			name: 'WorstPriceExceeded',
-			msg: 'WorstPriceExceeded',
+			name: 'BidNotCrossed',
+			msg: 'BidNotCrossed',
 		},
 		{
 			code: 6001,
+			name: 'AskNotCrossed',
+			msg: 'AskNotCrossed',
+		},
+		{
+			code: 6002,
 			name: 'TakerOrderNotFound',
 			msg: 'TakerOrderNotFound',
 		},

package/src/index.js

@@ -1,14 +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);

package/src/types/jit_proxy.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IDL = void 0;
-exports.IDL = {
-    "version": "0.1.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"
-                    }
-                }
-            ]
-        }
-    ],
-    "types": [
-        {
-            "name": "JitParams",
-            "type": {
-                "kind": "struct",
-                "fields": [
-                    {
-                        "name": "takerOrderId",
-                        "type": "u32"
-                    },
-                    {
-                        "name": "maxPosition",
-                        "type": "i64"
-                    },
-                    {
-                        "name": "worstPrice",
-                        "type": "u64"
-                    },
-                    {
-                        "name": "postOnly",
-                        "type": {
-                            "option": {
-                                "defined": "PostOnlyParam"
-                            }
-                        }
-                    }
-                ]
-            }
-        },
-        {
-            "name": "PostOnlyParam",
-            "type": {
-                "kind": "enum",
-                "variants": [
-                    {
-                        "name": "None"
-                    },
-                    {
-                        "name": "MustPostOnly"
-                    },
-                    {
-                        "name": "TryPostOnly"
-                    }
-                ]
-            }
-        }
-    ],
-    "errors": [
-        {
-            "code": 6000,
-            "name": "WorstPriceExceeded",
-            "msg": "WorstPriceExceeded"
-        },
-        {
-            "code": 6001,
-            "name": "TakerOrderNotFound",
-            "msg": "TakerOrderNotFound"
-        }
-    ]
-};