@triadxyz/triad-protocol 1.6.7-beta → 1.6.8-beta-dev

package/dist/trade.js

@@ -12,17 +12,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const trade_1 = require("./types/trade");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("./utils/constants");
 const helpers_1 = require("./utils/helpers");
-const trade_1 = require("./utils/pda/trade");
+const trade_2 = require("./utils/pda/trade");
 const sendVersionedTransaction_1 = __importDefault(require("./utils/sendVersionedTransaction"));
 const sendTransactionWithOptions_1 = __importDefault(require("./utils/sendTransactionWithOptions"));
-const swap_1 = require("./utils/swap");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
 class Trade {
     constructor(program, provider) {
         this.program = program;
         this.provider = provider;
+        this.mint = constants_1.USDC_MINT_DEVNET;
+        this.decimals = 6;
     }
     /**
      * Get All Markets
@@ -64,6 +67,67 @@ class Trade {
             return orders;
         });
     }
+    /**
+     * Get Orders By Market ID
+     * @param marketId - The ID of the market
+     *
+     */
+    getLimitOrdersByMarketId(marketId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketIdBytes = bytes_1.bs58.encode(new bn_js_1.default(marketId).toArrayLike(Buffer, 'le', 8));
+            const memcmpFilters = Array.from({ length: 10 }).map((_, index) => ({
+                memcmp: {
+                    offset: 8 + // discriminator
+                        1 + // bump
+                        32 + // authority
+                        8 + // total_deposits
+                        8 + // total_withdraws
+                        8 + // opened_orders
+                        // Per order: index * (8 + 8 + 8 + 8 + 1 + 8 + 8 + 8 + 1 + 1 + 4 + 28)
+                        index * (8 + 8 + 8 + 8 + 1 + 8 + 8 + 8 + 1 + 1 + 4 + 1 + 27) +
+                        // Then offset to market_id: 8 + 8 + 8
+                        (8 + 8 + 8),
+                    bytes: marketIdBytes
+                }
+            }));
+            const allResponses = yield Promise.all(memcmpFilters.map((filter) => this.program.account.userTrade.all([filter])));
+            const uniqueResponses = Array.from(new Map(allResponses.flat().map((item) => [item.publicKey.toString(), item])).values());
+            const userTrades = uniqueResponses.map(({ account, publicKey }) => (0, helpers_1.formatUserTrade)(account, publicKey));
+            const orders = userTrades.flatMap((userTrade) => userTrade.orders.map((order) => (Object.assign({}, order))));
+            const filteredOrders = orders.filter((order) => order.marketId === marketId.toString() &&
+                order.orderType === trade_1.OrderType.LIMIT &&
+                order.status === trade_1.OrderStatus.WAITING);
+            const orderBook = {
+                hype: {
+                    bid: [],
+                    ask: []
+                },
+                flop: {
+                    bid: [],
+                    ask: []
+                }
+            };
+            filteredOrders.forEach((order) => {
+                if (order.orderSide === trade_1.OrderSide.BID &&
+                    order.direction === trade_1.OrderDirection.HYPE) {
+                    orderBook.hype.bid.push(order);
+                    return;
+                }
+                if (order.orderSide === trade_1.OrderSide.ASK &&
+                    order.direction === trade_1.OrderDirection.HYPE) {
+                    orderBook.hype.ask.push(order);
+                    return;
+                }
+                if (order.orderSide === trade_1.OrderSide.BID &&
+                    order.direction === trade_1.OrderDirection.FLOP) {
+                    orderBook.flop.bid.push(order);
+                    return;
+                }
+                orderBook.flop.ask.push(order);
+            });
+            return orderBook;
+        });
+    }
     /**
      * Get Market By ID
      * @param marketId - The ID of the market
@@ -71,7 +135,7 @@ class Trade {
      */
     getMarketById(marketId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             const response = yield this.program.account.marketV2.fetch(marketPDA);
             return (0, helpers_1.formatMarket)(response, marketPDA);
         });
@@ -95,16 +159,16 @@ class Trade {
      */
     getUserTrade(user, userNonce = 0) {
         return __awaiter(this, void 0, void 0, function* () {
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, user);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, user);
             if (userNonce !== 0) {
-                const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, user, userNonce);
-                userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, user, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
             return this.program.account.userTrade.fetch(userTradePDA);
         });
     }
     /**
-     * Initialize Market
+     * Create Market
      * @param args.marketId - new markert id - length + 1
      * @param args.startTime - start time
      * @param args.endTime - end time
@@ -113,21 +177,24 @@ class Trade {
      * @param options - RPC options
      *
      */
-    initializeMarket({ marketId, startTime, endTime, question }, options) {
+    createMarket({ marketId, startTime, endTime, question, feeBps, customer }, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (question.length > 80) {
                 throw new Error('Question must be less than 80 characters');
             }
             return (0, sendTransactionWithOptions_1.default)(this.program.methods
-                .initializeMarket({
+                .createMarket({
                 marketId: new bn_js_1.default(marketId),
                 question: (0, helpers_1.encodeString)(question, 80),
                 marketStart: new bn_js_1.default(startTime),
-                marketEnd: new bn_js_1.default(endTime)
+                marketEnd: new bn_js_1.default(endTime),
+                feeBps
             })
                 .accounts({
                 signer: this.provider.publicKey,
-                mint: constants_1.TRD_MINT
+                mint: this.mint,
+                tokenProgram: (0, helpers_1.getTokenProgram)(this.mint),
+                customer
             }), options);
         });
     }
@@ -143,44 +210,51 @@ class Trade {
                 if (nonce !== null) {
                     break;
                 }
+                let freeSlots = 0;
                 userTrade.orders.forEach((order) => {
                     if (nonce !== null) {
                         return;
                     }
-                    let status = Object.keys(order.status)[0];
-                    if (status !== 'open') {
+                    if (order.status !== trade_1.OrderStatus.OPEN &&
+                        order.status !== trade_1.OrderStatus.WAITING &&
+                        freeSlots >= 2) {
                         nonce = userTrade.isSubUser ? Number(userTrade.nonce) : 0;
                     }
+                    if (order.status !== trade_1.OrderStatus.OPEN &&
+                        order.status !== trade_1.OrderStatus.WAITING) {
+                        freeSlots += 1;
+                    }
                 });
             }
             if (nonce === null) {
                 throw new Error('No open orders found');
             }
             if (nonce === 0) {
-                return (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+                return (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             }
-            const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, nonce);
-            const userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+            const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, nonce);
+            const userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             return userTradePDA;
         });
     }
     /**
-     * Open Order
+     * Place Order
      * @param args.marketId - The ID of the Market
      * @param args.amount - The amount of the Order
      * @param args.direction - The direction of the Order
-     * @param args.token - The token to use for the Order
+     * @param args.orderSide - The side of the Order
+     * @param args.mint - The mint of the Order
+     * @param args.price - The price of the Order
      *
      * @param options - RPC options
      *
      */
-    openOrder({ marketId, amount, direction, token }, options) {
+    placeOrder({ marketId, amount, direction, orderSide, mint, price }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             const ixs = [];
             const addressLookupTableAccounts = [];
-            let amountInTRD = amount * Math.pow(10, constants_1.TRD_DECIMALS);
             let myUserTrades = [];
             myUserTrades = yield this.getMyUserTrades(this.provider.publicKey);
             if (myUserTrades.length === 0) {
@@ -194,11 +268,31 @@ class Trade {
             if (myUserTrades.length > 0) {
                 try {
                     userTradePDA = yield this.getUserTradeNonceWithSlots(myUserTrades);
+                    console.log(userTradePDA);
+                    // Check if we need to create a new sub user trade
+                    // This happens when all existing slots have open orders
+                    const allSlotsHaveOpenOrders = myUserTrades.every((trade) => trade.orders.some((order) => Object.keys(order.status)[0] === 'open' ||
+                        Object.keys(order.status)[0] === 'waiting'));
+                    if (allSlotsHaveOpenOrders) {
+                        // Find the main user trade to get the current nonce
+                        const mainUserTrade = myUserTrades.find((userTrade) => !userTrade.isSubUser);
+                        if (!mainUserTrade) {
+                            throw new Error('No main user trade found');
+                        }
+                        const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                        ixs.push(yield this.program.methods
+                            .createSubUserTrade(subUserTradePDA)
+                            .accounts({
+                            signer: this.provider.publicKey
+                        })
+                            .instruction());
+                    }
                 }
-                catch (_a) {
+                catch (error) {
+                    console.log(error);
                     const mainUserTrade = myUserTrades.find((userTrade) => !userTrade.isSubUser);
-                    const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
-                    userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                    const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                    userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
                     ixs.push(yield this.program.methods
                         .createSubUserTrade(subUserTradePDA)
                         .accounts({
@@ -207,38 +301,41 @@ class Trade {
                         .instruction());
                 }
             }
-            if (token !== constants_1.TRD_MINT.toBase58()) {
-                const { setupInstructions, swapIxs, addressLookupTableAccounts, trdAmount } = yield (0, swap_1.swap)({
-                    connection: this.provider.connection,
-                    wallet: this.provider.publicKey.toBase58(),
-                    inToken: token,
-                    amount
-                });
-                amountInTRD = trdAmount;
-                if (swapIxs.length === 0) {
-                    return;
-                }
-                ixs.push(...setupInstructions);
-                ixs.push(...swapIxs);
-                addressLookupTableAccounts.push(...addressLookupTableAccounts);
+            if (Object.keys(orderSide)[0] === 'bid') {
+                ixs.push(yield this.program.methods
+                    .placeBidOrder({
+                    amount: new bn_js_1.default(amount * Math.pow(10, this.decimals)),
+                    price: new bn_js_1.default(price * Math.pow(10, this.decimals)),
+                    orderDirection: direction
+                })
+                    .accounts({
+                    signer: this.provider.publicKey,
+                    market: marketPDA,
+                    userTrade: userTradePDA,
+                    mint,
+                    tokenProgram: (0, helpers_1.getTokenProgram)(mint)
+                })
+                    .instruction());
+            }
+            if (Object.keys(orderSide)[0] === 'ask') {
+                ixs.push(yield this.program.methods
+                    .placeAskOrder({
+                    shares: new bn_js_1.default(amount * Math.pow(10, this.decimals)),
+                    price: new bn_js_1.default(price * Math.pow(10, this.decimals)),
+                    orderDirection: direction
+                })
+                    .accounts({
+                    signer: this.provider.publicKey,
+                    market: marketPDA,
+                    userTrade: userTradePDA
+                })
+                    .instruction());
             }
-            ixs.push(yield this.program.methods
-                .openOrder({
-                amount: new bn_js_1.default(amountInTRD),
-                direction: direction
-            })
-                .accounts({
-                signer: this.provider.publicKey,
-                market: marketPDA,
-                userTrade: userTradePDA,
-                mint: constants_1.TRD_MINT
-            })
-                .instruction());
             return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, undefined, addressLookupTableAccounts);
         });
     }
     /**
-     * Close Order
+     * Cancel Order
      * @param args.marketId - The ID of the Market
      * @param args.orderId - The ID of the Order
      * @param args.userNonce - The nonce of the user
@@ -246,42 +343,23 @@ class Trade {
      * @param options - RPC options
      *
      */
-    closeOrder({ marketId, orderId, userNonce }, options) {
+    cancelOrder({ marketId, orderId, userNonce }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             if (userNonce !== 0) {
-                const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
-                userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.closeOrder(new bn_js_1.default(orderId)).accounts({
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.cancelOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
-                mint: constants_1.TRD_MINT,
-                userTrade: userTradePDA
+                mint: this.mint,
+                userTrade: userTradePDA,
+                tokenProgram: (0, helpers_1.getTokenProgram)(this.mint)
             }), options);
         });
     }
-    /**
-     * Resolve Market
-     * @param args.marketId - The ID of the Market
-     * @param args.winningDirection - The Winning Direction of the Market
-     *
-     * @param options - RPC options
-     *
-     */
-    resolveMarket({ marketId, winningDirection }, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            const method = this.program.methods
-                .resolveMarket(winningDirection)
-                .accounts({
-                signer: this.provider.publicKey,
-                market: marketPDA
-            });
-            return (0, sendTransactionWithOptions_1.default)(method, options);
-        });
-    }
     /**
      * Collect Remaining Liquidity
      * @param marketId - The ID of the market
@@ -291,11 +369,11 @@ class Trade {
      */
     collectRemainingLiquidity(marketId, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.collectRemainingLiquidity().accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA,
-                mint: constants_1.TRD_MINT
+                mint: this.mint
             }), options);
         });
     }
@@ -310,17 +388,17 @@ class Trade {
      */
     payoutOrder({ marketId, orderId, userNonce }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            let userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
             if (userNonce !== 0) {
-                const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
-                userTradePDA = (0, trade_1.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
             }
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.payoutOrder(new bn_js_1.default(orderId)).accounts({
                 signer: this.provider.publicKey,
                 userTrade: userTradePDA,
                 market: marketPDA,
-                mint: constants_1.TRD_MINT
+                mint: this.mint
             }), options);
         });
     }
@@ -333,7 +411,7 @@ class Trade {
      */
     allowMarketToPayout(marketId, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.allowMarketToPayout().accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA
@@ -350,7 +428,7 @@ class Trade {
     createSubUserTrade(user, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const userTrade = yield this.getUserTrade(user);
-            const subUserTradePDA = (0, trade_1.getSubUserTradePDA)(this.program.programId, user, userTrade.nonce + 1);
+            const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, user, userTrade.nonce + 1);
             return (0, sendTransactionWithOptions_1.default)(this.program.methods.createSubUserTrade(subUserTradePDA).accounts({
                 signer: this.provider.publicKey
             }), options);
@@ -360,18 +438,125 @@ class Trade {
      * Update Market
      * @param marketId - The ID of the market
      * @param marketEnd - The end time of the market
+     * @param winningDirection - The winning direction of the market
      *
      * @param options - RPC options
      *
      */
-    updateMarket(marketId, marketEnd, options) {
+    updateMarket({ marketId, marketEnd, winningDirection }, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const marketPDA = (0, trade_1.getMarketPDA)(this.program.programId, marketId);
-            return (0, sendTransactionWithOptions_1.default)(this.program.methods.updateMarket(new bn_js_1.default(marketEnd)).accounts({
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods
+                .updateMarket({
+                marketEnd: marketEnd ? new bn_js_1.default(marketEnd) : undefined,
+                winningDirection
+            })
+                .accounts({
                 signer: this.provider.publicKey,
                 market: marketPDA
             }), options);
         });
     }
+    /**
+     * Create Customer
+     * @param args.id - The ID of the customer
+     * @param args.name - The name of the customer
+     * @param args.authority - The authority of the customer
+     * @param args.shadowStorage - The shadow storage of the customer
+     *
+     * @param options - RPC options
+     *
+     */
+    createCustomer({ id, name, authority, shadowStorage }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods
+                .createCustomer({ id, name, authority, shadowStorage })
+                .accounts({
+                signer: this.provider.publicKey
+            }), options);
+        });
+    }
+    /**
+     * Open Order
+     * @param args.marketId - The ID of the Market
+     * @param args.amount - The amount of the Order
+     * @param args.direction - The direction of the Order
+     *
+     * @param options - RPC options
+     *
+     */
+    openOrder({ marketId, amount, direction }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            const ixs = [];
+            const addressLookupTableAccounts = [];
+            let amountInTRD = amount * Math.pow(10, constants_1.TRD_DECIMALS);
+            let myUserTrades = [];
+            myUserTrades = yield this.getMyUserTrades(this.provider.publicKey);
+            if (myUserTrades.length === 0) {
+                ixs.push(yield this.program.methods
+                    .createUserTrade()
+                    .accounts({
+                    signer: this.provider.publicKey
+                })
+                    .instruction());
+            }
+            if (myUserTrades.length > 0) {
+                try {
+                    userTradePDA = yield this.getUserTradeNonceWithSlots(myUserTrades);
+                }
+                catch (_a) {
+                    const mainUserTrade = myUserTrades.find((userTrade) => !userTrade.isSubUser);
+                    const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, Number(mainUserTrade.nonce) + 1);
+                    userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
+                    ixs.push(yield this.program.methods
+                        .createSubUserTrade(subUserTradePDA)
+                        .accounts({
+                        signer: this.provider.publicKey
+                    })
+                        .instruction());
+                }
+            }
+            ixs.push(yield this.program.methods
+                .openOrder({
+                amount: new bn_js_1.default(amountInTRD),
+                direction: direction
+            })
+                .accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA,
+                userTrade: userTradePDA,
+                mint: this.mint
+            })
+                .instruction());
+            return (0, sendVersionedTransaction_1.default)(this.provider, ixs, options, undefined, addressLookupTableAccounts);
+        });
+    }
+    /**
+     * Close Order
+     * @param args.marketId - The ID of the Market
+     * @param args.orderId - The ID of the Order
+     * @param args.userNonce - The nonce of the user
+     *
+     * @param options - RPC options
+     *
+     */
+    closeOrder({ marketId, orderId, userNonce }, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPDA = (0, trade_2.getMarketPDA)(this.program.programId, marketId);
+            let userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, this.provider.publicKey);
+            if (userNonce !== 0) {
+                const subUserTradePDA = (0, trade_2.getSubUserTradePDA)(this.program.programId, this.provider.publicKey, userNonce);
+                userTradePDA = (0, trade_2.getUserTradePDA)(this.program.programId, subUserTradePDA);
+            }
+            return (0, sendTransactionWithOptions_1.default)(this.program.methods.closeOrder(new bn_js_1.default(orderId)).accounts({
+                signer: this.provider.publicKey,
+                market: marketPDA,
+                mint: this.mint,
+                userTrade: userTradePDA
+            }), options);
+        });
+    }
 }
 exports.default = Trade;